HOJ1127听风

最新推荐文章于 2023-04-08 13:32:55 发布
最新推荐文章于 2023-04-08 13:32:55 发布
阅读量107 收藏
点赞数
原文链接：http://www.cnblogs.com/Shiina-Rikka/p/11541759.html
版权

HOJ1127听风

该网页无法正常运作

题面（题面难懂这就是语文题）

一棵根节点为1的树，所有边权均为1，每个节点有不同的颜色C。对这棵树进行游览并统计贡献。

游览方式

  1. 如果一个节点被游览过就不再游览。
  2. 如果在i号节点，它是叶子节点或者所有儿子都被游览过则停在该节点。

  3. 如果第 i号节点存在儿子没有游览过，则挑选所有未游览的儿子中val[x]最小的一个继续行走。val[x] = min{y|y\({\in}\)x的子树}。
    可以任意选择在游览几个节点后结束游览

    每游览一个节点，贡献会加上 这个节点到根节点以及它的子树中颜色的种类 \({-}\) 这个节点到根节点的路径长度

游览结束后，会给很多路径

贡献会加上max(每条路径上被游览的点数 \({-1}\), \({0}\))\({*}\)题目提供的权值z

最终答案为游览结束后的所有可能贡献中的最大值

原题面不太合适扔在这里 不放了

这题该咋做

首先dfs求出游览的顺序，然后树上差分，把最后路径的权值扔到节点上，最后按照游览顺序遍历这颗树，统计当前的总贡献，与答案取max。
至于节点的颜色，因为数据比较小bitset状态压缩就可以过。
std给的是dsu on tree，大概学了一学然后滚来更新。

涉及的知识点

LCA

LCA模板
这题我用倍增毕竟Tarjan不会。

树上差分

其实是第一次写树上差分
这道题在处理路径的时候使用树上差分。但是给的是路径上节点数-1，该怎么处理呢？
由于游览顺序已知，我们只要不记录这条路径上最先被游览的节点，就可以保证在计算这条路径时有-1的效果。
树上差分的标记是打在左右两个节点的，我们只要挑选出这两个中先被游览的点，把标记打在他的父亲即可。

dsu on tree

一个好题
这个就像是在树上进行启发式合并。
简单的来说，把重儿子子树信息扔到父亲上，轻儿子则扔掉，这样可以保证复杂度\({n\log{n}}\)。（回头写博客吧）这个题还要维护链的信息所以dfs要多记一下信息。

代码

这个是bitset的代码，极慢，卡着空间。。。

#include <iostream>
#include <cstdio>
#include <bitset>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <ctime>
namespace fdata
{
inline char nextchar()
{
    static const int BS = 1 << 21;
    static char buf[BS], *st, *ed;
    if (st == ed)
        ed = buf + fread(st = buf, 1, BS, stdin);
    return st == ed ? -1 : *st++;
}
template <typename T>
inline T poread()
{
    T ret = 0;
    char ch;
    while (!isdigit(ch = nextchar()))
        ;

    do
        ret = ret * 10 + ch - '0';
    while (isdigit(ch = nextchar()));
    return ret;
}
} // namespace fdata
using fdata::poread;
using namespace std;
const int INF = 1 << 29;
const int MAXN = 1e5 + 5;
const int MAXC = 4e3 + 7;
int n, m, c, t;
int head[MAXN], ver[MAXN << 1], nxt[MAXN << 1], tot; //邻接表
inline void add(const int &x, const int &y)
{
    ver[++tot] = y;
    nxt[tot] = head[x];
    head[x] = tot;
}
struct node //记录节点信息
{
    bitset<MAXC> lian, c;
    vector<int> vct;
    int deep;
    int son;
    int siz;
} pt[MAXN];
int dfn[MAXN], cnt;
int f[MAXN][19]; // lca
bool cmp(const int &x, const int &y)
{
    return pt[x].son < pt[y].son;
}
void dfs1(int x) //处理子树集合，父亲节点
{
    pt[x].son = x;
    pt[x].lian |= pt[f[x][0]].lian;
    for (register int i = head[x], y = ver[i]; i; i = nxt[i], y = ver[i])
    {
        if (y == f[x][0])
            continue;
        dfs1(y);
        pt[x].c |= pt[y].c;
        pt[x].son = min(pt[x].son, pt[y].son);
    }
}
void dfs2(int x)
{
    for (register int i = head[x]; i; i = nxt[i])
        if (ver[i] != f[x][0])
            pt[x].vct.push_back(ver[i]);
    sort(pt[x].vct.begin(), pt[x].vct.end(), cmp);
    for (register vector<int>::iterator it = pt[x].vct.begin(); it != pt[x].vct.end(); ++it)
        dfs2(*it);
    dfn[x] = ++cnt;
    pt[x].vct.clear();
}
int lca(int x, int y)
{
    if (pt[x].deep > pt[y].deep)
        swap(x, y);
    int t = (int)(log(n) / log(2)) + 1;
    for (register int i = t; i >= 0; --i)
    {
        if (pt[f[y][i]].deep >= pt[x].deep)
            y = f[y][i];
    }
    if (y == x)
        return x;
    for (register int i = t; i >= 0; --i)
        if (f[x][i] != f[y][i])
            x = f[x][i], y = f[y][i];
    return f[x][0];
}
long long Ans = 0;
long long ans = 0;
void dfs3(int x)
{
    for (register int i = head[x]; i; i = nxt[i])
    {
        int y = ver[i];
        if (y == f[x][0])
            continue;
        dfs3(y);
        pt[x].siz += pt[y].siz;
    }
}
void dfs4(int x)
{
    for (register int i = head[x]; i; i = nxt[i])
        if (ver[i] != f[x][0])
            pt[x].vct.push_back(ver[i]);
    sort(pt[x].vct.begin(), pt[x].vct.end(), cmp);
    for (register vector<int>::iterator it = pt[x].vct.begin(); it != pt[x].vct.end(); ++it)
        dfs4(*it);
    ans = (long long)ans + (1ll * pt[x].lian.count() - pt[x].deep + 1) + (1ll * pt[x].siz);
    Ans = max(ans, Ans);
    pt[x].vct.clear();
}
inline void bfs()
{
    queue<int> q;
    q.push(1);
    pt[1].deep = 1;
    f[1][0] = -1;
    while (q.size())
    {
        int x = q.front();
        q.pop();
        for (register int i = head[x], y = ver[i]; i; i = nxt[i], y = ver[i])
        {
            if (pt[y].deep)
                continue;
            pt[y].deep = pt[x].deep + 1;
            f[y][0] = x;
            for (register int j = 1; j <= t; ++j)
            {
                f[y][j] = f[f[y][j - 1]][j - 1];
            }
            q.push(y);
        }
    }
    while (q.size())
        q.pop();
}
bitset<MAXC> iii;
signed main()
{
#ifdef lky233
    freopen("testdata.in", "r", stdin);
    freopen("testdata.out", "w", stdout);
#endif
    n = poread<int>(), m = poread<int>(), c = poread<int>();
    t = log(n) / log(2) + 1;
    for (register int i = 1; i <= n; ++i)
        pt[i].lian[poread<int>()] = true, pt[i].c = pt[i].lian;
    for (register int i = 1, x, y; i < n; ++i)
    {
        x = poread<int>(), y = poread<int>();
        add(x, y), add(y, x);
    }
    bfs();
    dfs1(1);
    for (register int i = 1; i <= n; ++i)
        pt[i].lian = pt[i].c | pt[i].lian;
    dfs2(1);
    for (register int i = 1, x, y, z; i <= m; ++i)
    {
        x = poread<int>(), y = poread<int>(), z = poread<int>();
        if (x == y)
            continue;
        if (dfn[x] >= dfn[y])
            swap(x, y);
        x = f[x][0];
        if (x)
            pt[x].siz += z;
        if (y)
            pt[y].siz += z;
        int L = lca(x, y);
        if (L)
            pt[L].siz -= z;
        if (f[L][0])
            pt[f[L][0]].siz -= z;
        // cerr << x << y << L << f[L][0] << endl;
    }
    dfs3(1);
    dfs4(1);
    cerr << "ans: ";
    cerr << Ans << endl;
    cout << Ans << endl;
    cerr << clock() << "ms" << endl;
    return 0;
}

我回来补上 dsu on tree 了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <ctime>
namespace fdata
{
inline char nextchar()
{
    static const int BS = 1 << 21;
    static char buf[BS], *st, *ed;
    if (st == ed)
        ed = buf + fread(st = buf, 1, BS, stdin);
    return st == ed ? -1 : *st++;
}
template <typename T>
inline T poread()
{
    T ret = 0;
    char ch;
    while (!isdigit(ch = nextchar()))
        ;

    do
        ret = ret * 10 + ch - '0';
    while (isdigit(ch = nextchar()));
    return ret;
}
} // namespace fdata
using fdata::poread;
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXC = 4e3 + 5;
int n, m, c;
struct Edge
{
    int ver, nxt;
} edge[MAXN << 1];
int head[MAXN], tot;
inline void add(const int &x, const int &y)
{
    edge[++tot].ver = y;
    edge[tot].nxt = head[x];
    head[x] = tot;
}
struct Point
{
    vector<int> vct;
    set<int> map;
    int x;
    // 子树大小  重儿子 路径儿子
    int siz, son, rson, deep;
    //节点颜色  子树颜色数    权值
    int color, sumcolor, sum;
} pt[MAXN];
int _cnt;
int dfn[MAXN];
int cnt[MAXC];
int rt[MAXN];
int f[MAXN][19];
inline bool cmp(const int &x, const int &y)
{
    return pt[x].rson < pt[y].rson;
}
inline bool cmp2(const Point &x, const Point &y)
{
    return dfn[x.x] < dfn[y.x];
}
//一遍bfs预处理求lca
inline void bfs()
{
    queue<int> q;
    int t = log(n) / log(2) + 1;
    q.push(1);
    pt[1].deep = 1;
    f[1][0] = 0;
    while (q.size())
    {
        register int x = q.front();
        q.pop();
        for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
        {
            if (pt[y].deep)
                continue;
            pt[y].deep = pt[x].deep + 1;
            f[y][0] = x;
            for (register int j = 1; j <= t; ++j)
                f[y][j] = f[f[y][j - 1]][j - 1];
            q.push(y);
        }
    }
    while (q.size())
        q.pop();
}
inline int lca(const int &X, const int &Y)
{
    int x = X, y = Y;
    int t = (log(n) / log(2)) + 1;
    if (pt[x].deep > pt[y].deep)
        swap(x, y);
    for (register int i = t; i >= 0; --i)
    {
        if (pt[f[y][i]].deep >= pt[x].deep)
            y = f[y][i];
    }
    if (x == y)
        return x;
    for (register int i = t; i >= 0; --i)
    {
        if (f[x][i] != f[y][i])
            x = f[x][i], y = f[y][i];
    }
    return f[x][0];
}
//处理重儿子,路径儿子,子树大小
void dfs1(int x)
{
    pt[x].siz = 1;
    pt[x].rson = x;
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
    {
        if (y == f[x][0])
            continue;
        dfs1(y);
        pt[x].siz += pt[y].siz;
        pt[x].rson = min(pt[x].rson, pt[y].rson);
        if (pt[pt[x].son].siz <= pt[y].siz)
            pt[x].son = y;
    }
}
void dfs2(int x)
{
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
        if (y != f[x][0])
            pt[x].vct.push_back(y);
    sort(pt[x].vct.begin(), pt[x].vct.end(), cmp);
    for (register vector<int>::iterator it = pt[x].vct.begin(); it != pt[x].vct.end(); ++it)
        dfs2(*it);
    dfn[x] = ++_cnt;
    pt[x].vct.clear();
}
void dfs3(int x)
{
    if (!cnt[pt[x].color])
        ++_cnt;
    cnt[pt[x].color]++;
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
    {
        if (y == f[x][0])
            continue;
        dfs3(y);
        pt[x].sumcolor += pt[y].sumcolor;
    }
    if (pt[x].son)
        rt[x] = rt[pt[x].son], pt[x].sumcolor = pt[pt[x].son].sumcolor;
    else
        rt[x] = x, pt[x].sumcolor = _cnt;
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
    {
        if (y == f[x][0] || y == pt[x].son)
            continue;
        y = rt[y];
        for (register set<int>::iterator it = pt[y].map.begin(); it != pt[y].map.end(); ++it)
        {
            register int tmp = *it;
            if (pt[rt[x]].map.find(tmp) == pt[rt[x]].map.end())
            {
                if (!cnt[tmp])
                    ++pt[x].sumcolor;
                pt[rt[x]].map.insert(tmp);
            }
        }
        pt[y].map.clear();
    }
    --cnt[pt[x].color];
    if (!cnt[pt[x].color])
        _cnt--;
    pt[rt[x]].map.insert(pt[x].color);
}
long long ans = 0, Ans = 0;
void dfs4(int x)
{
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
        if (y != f[x][0])
            pt[x].vct.push_back(y);
    sort(pt[x].vct.begin(), pt[x].vct.end(), cmp);
    for (register vector<int>::iterator it = pt[x].vct.begin(); it != pt[x].vct.end(); ++it)
        dfs4(*it);
    ans = (long long)ans + ((1ll * pt[x].sumcolor) - pt[x].deep + 1) + (1ll * pt[x].sum);
    Ans = max(ans, Ans);
    pt[x].vct.clear();
}
void dfs5(int x)
{
    for (register int i = head[x], y = edge[i].ver; i; i = edge[i].nxt, y = edge[i].ver)
    {
        if (y == f[x][0])
            continue;
        dfs5(y);
        pt[x].sum += pt[y].sum;
    }
}
int main()
{
#ifdef lky233
    freopen("testdata.in", "r", stdin);
    freopen("testdata.out", "w", stdout);
#endif
    n = poread<int>(), m = poread<int>(), c = poread<int>();
    for (register int i = 1; i <= n; ++i)
        pt[i].color = poread<int>();
    for (register int i = 1; i <= n; ++i)
        pt[i].x = i;
    for (register int i = 1, x, y; i < n; ++i)
    {
        x = poread<int>(), y = poread<int>();
        add(x, y);
        add(y, x);
    }
    bfs();
    dfs1(1);
    dfs2(1);
    _cnt = 0;
    dfs3(1);
    for (register int i = 1, x, y, z; i <= m; ++i)
    {
        x = poread<int>(), y = poread<int>(), z = poread<int>();
        if (x == y)
            continue;
        if (dfn[x] >= dfn[y])
            swap(x, y);
        x = f[x][0];
        if (x)
            pt[x].sum += z;
        if (y)
            pt[y].sum += z;
        int L = lca(x, y);
        if (L)
            pt[L].sum -= z;
        if (f[L][0])
            pt[f[L][0]].sum -= z;
    }
    dfs5(1);
    dfs4(1);
    cerr << "ans: " << Ans << endl;
    cerr << clock() << "ms" << endl;
    cout << Ans << endl;
}

坑点

在树上差分标记的时候，给了一个1-1的路径，这个时候父亲跳到了上面，0有了+3-3-3的标记，1有了+3的标记，查询时导致少了-3，挂掉了。

大概这样 画的难看

感谢nofind大佬解释题面，教我树上差分。
感谢Chrisk大佬指出排版错误，已修正。
ありがとうございました。

已完结

可能指不定哪天回来发个图解释一下做法

转载于:https://www.cnblogs.com/Shiina-Rikka/p/11541759.html

dongdao7825
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HOJ题目备份，值得拥有
12-09
【标题】"HOJ题目备份，值得拥有"指的是在编程竞赛平台HOJ（华中科技大学在线评测系统）上的题目资源备份。这样的备份通常是为了防止数据丢失，方便参赛者或者编程爱好者随时查阅和练习过去的题目。 【描述】"HOJ...
hoj小部分题
06-07
【hoj小部分题】是针对HOJ（华中科技大学在线评测系统）中部分编程题目的集合，这些题目涵盖了不同的编程挑战，旨在帮助用户提升编程技能和算法理解。标签"hoj"表明这些题目来源于一个专门的编程竞赛或训练平台。...
HOJ搭建教程
城南蝈蝈
06-19 4025
online judge系统。开源OJ搭建过程 HOJ搭建过程
HOJ-1005 - Fast Food
Edith_Finch的博客
10-24 251
题目 HOJ-1005 - Fast Food 思路分析 一开始看数据太大就知道肯定要用动态规划，但失败了（日常蒟蒻 1/∞）。百度题解后才发现自己的状态转移方程有误。状态不应该由前一个餐馆转移过来，应该从上一次建立的存储点转移过来。因此设计状态f[i][j]表示前j个餐馆设立了i个存储点时的最优解。则状态转移方程为 f[i][j]=min{f[i][j],f[i−1][k]+g[k][j]} f...
HOJ 题目分类
弱者要战斗
10-29 1257
****************************************************************************** * 简单题（包括枚举，二分查找，（复杂）模拟，基础数据结构（栈、队列），杂题等 * *****************************************************************************
HOJ-1008
xlh006的博客
09-05 246
确实水题，不难 硬是要挑一个唯一的话，=》：                                 while(cin &gt;&gt; N,N)   代码实现： #include &lt;iostream&gt; using namespace std; int main() {     int N;     while(cin &gt;&gt; N,N){       ...
HOJ cake
Coding
02-12 342
Cake Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3685 Accepted Submission(s): 1753 Problem Description 一次生
HOJ2136 素数，筛选法
仅余我与暮色平分此世界
07-24 191
Problem Description Everybody knows any number can be combined by the prime number. Now, your task is telling me what position of the largest prime factor. The position of prime 2 is 1, prime 3 is 2, ...
Kruscal算法 HOJ.1863 畅通工程
一粒大榴莲的博客
05-06 161
Problem Description 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。 Input 测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随...
大数加法——HOJ1002
zykimmy的博客
12-05 557
HOJ1002 /* 算法原理： *********************************************************** ①用数组存储数字（输入的顺序与大数的个十百千万位刚好相反） ②在加的过程中转换成数字（-‘0’） / 运算得到进位的大小（数字表示） % 运算得到此位的数字，转换为字符存储到temp（+‘0’） ③注意最后的进位，相加最多进一位，因
WSL下配置HOJ后端环境
qq_48230195的博客
04-08 941
由于判题机需要Linux环境，请在windows下准备好wsl环境并安装好ubuntu子系统。wsl安装好，并安装unbuntu子系统（其它Linux发行版也可以，前提得驾驭得了）潘集要想正常地本地判题，本地就必须有对应的语言环境 这个需要自己配置。这个要在Linux环境下启动，cd 到对应文件夹下./文件名就好了。其它环境如 mysql、redis请参考下面的文档进行操作，下载Linux版本的 java8版本jdk与maven。选择与自己电脑对应的指令集版本 选择tar.gz版本。
hoj.rar_HOJ
09-23
【hoj.rar_HOJ】是一个压缩包文件，其中包含了与HOJ（ Hacker's Online Judge 或者 Home Of Judges，一个在线编程竞赛平台）相关的部分题目解题报告。这些报告可能涵盖了C、C++或Java等编程语言的解决方案，是学习...
hoj.rar_hoj杭州
09-14
标题中的"hoj.rar_hoj杭州"表明这是一个与杭州电子科技大学的在线判题系统（Online Judge，简称OJ）相关的压缩文件，其中包含了参赛者或学习者提交的代码。"hoj"通常指的是"杭电OJ"，一个用于编程竞赛和训练的平台。...
HOJ.rar_HOJ_hoj2055_oj_绘图软件
09-22
【标题】"HOJ.rar_HOJ_hoj2055_oj_绘图软件" 涉及的主要是编程竞赛平台的相关知识，特别是针对杭州电子科技大学的ACM在线判题系统（Online Judge，简称OJ）的部分源代码。这个压缩包可能是用于教学或自我提升数据...
互联网生态峰会PPT模板
07-13
【作品名称】：互联网生态峰会PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
钢管扣件质量检查表.docx
07-13
钢管扣件质量检查表.docx
Foxit-Installer-Clean-Up
07-13
福昕编辑器残留清除工具
培训课件 -安全生产月--几种常见的现场急救方法.pptx
最新发布
07-13
培训课件 -安全生产月--几种常见的现场急救方法.pptx
设计一个8K*8位存储器，采用74LS138译码器和 2K*8位的RAM芯片组成，使其寻址存储器地址范 围为4000H~5FFFH。（需要画出连接示意图）
06-13
[存储器连接示意图](https://i.imgur.com/SGO0HoJ.png) 存储器连接示意图说明： - 地址总线A13和A14通过74LS138译码器进行译码，将地址范围限定在4000H~5FFFH。 - 74LS138译码器的三个输入端口（A, B, C）用来接收...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值