树链剖分+线段树+离线（广州网选赛第八题hdu5029）

最新推荐文章于 2019-07-17 14:13:16 发布

panshangqi

最新推荐文章于 2019-07-17 14:13:16 发布

阅读量792

点赞数

CC 4.0 BY-SA版权

分类专栏：树链剖分

本文链接：https://blog.youkuaiyun.com/mypsq/article/details/39498137

树链剖分专栏收录该内容

10 篇文章

订阅专栏

本文深入探讨了信息技术领域的核心内容，包括但不限于前端开发、后端开发、移动开发、游戏开发、大数据开发、开发工具、嵌入式硬件、嵌入式电路知识、嵌入式开发环境、音视频基础、音视频直播流媒体、图像处理AR特效、AI音视频处理、测试、基础运维、DevOps、操作系统、云计算厂商、自然语言处理、区块链、隐私计算、文档协作与知识管理、版本控制、项目管理与协作工具、有监督学习、无监督学习、半监督学习、强化学习、数据安全、数据挖掘、数据结构、算法等。文章详细介绍了各领域的关键概念、技术和应用实例，旨在为读者提供全面深入的技术知识。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

http://acm.hdu.edu.cn/showproblem.php?pid=5029

Relief grain

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 100000/100000 K (Java/Others)

Total Submission(s): 405 Accepted Submission(s): 95

Problem Description

The soil is cracking up because of the drought and the rabbit kingdom is facing a serious famine. The RRC(Rabbit Red Cross) organizes the distribution of relief grain in the disaster area.

We can regard the kingdom as a tree with n nodes and each node stands for a village. The distribution of the relief grain is divided into m phases. For each phases, the RRC will choose a path of the tree and distribute some relief grain of a certain type for every village located in the path.

There are many types of grains. The RRC wants to figure out which type of grain is distributed the most times in every village.

Input

The input consists of at most 25 test cases.

For each test case, the first line contains two integer n and m indicating the number of villages and the number of phases.

The following n-1 lines describe the tree. Each of the lines contains two integer x and y indicating that there is an edge between the x-th village and the y-th village.

The following m lines describe the phases. Each line contains three integer x, y and z indicating that there is a distribution in the path from x-th village to y-th village with grain of type z. (1 <= n <= 100000, 0 <= m <= 100000, 1 <= x <= n, 1 <= y <= n, 1 <= z <= 100000)

The input ends by n = 0 and m = 0.

Output

For each test case, output n integers. The i-th integer denotes the type that is distributed the most times in the i-th village. If there are multiple types which have the same times of distribution, output the minimal one. If there is no relief grain in a village, just output 0.

Sample Input

Sample Output

题意：给出一棵树，然后有一系列的操作，每次操作有a，b，c代表在a到b的路径上的每个点都给一个c类型的数字；最后问所有操作完成后树上的每个节点拥有的数量最多的类型是多少，如果存在多个输出较小类型的数字；

分析：首先这种在树上的操作，很容易想到是树链剖分的题目，但是具体该怎么写呢：先不考虑树的问题，可以把题意抽象出一个普通的连续区间【1，n】，然后在不同区间进行分配东西，最后问每个点的结果，对于区间【L,R】上分配一个数字Z，那么就在L位置上标记+Z,代表从此时以后的每个节点都拥有一个Z，然后在R+1的位置上标记一个-Z，代表从该节点开始没有分配Z这个数字；所以先把m个操作记录下来，对于每个标记的节点，可以用一个vector容器记录所标记的东西，接下来我们可以建立一个权值线段树区间【1,100000】；每个点分别代表数字Z的类型，px数组代表每个类型数字当前出现的次数；tree[i].maxi代表i区间的最大值，从左向右遍历区间【1，n】，对于每个节点更新px的值，如果标记是+Z,则px[z]++;否则px[-z]--；然后query即可；

树链剖分也是同样的道理，轻重链的划分不详说了，对于一个树上的两点<u,v>，把它转化为多条连续的子链利用线段树操作即可；具体程序如下：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include"stdio.h"
#include"string.h"
#include"iostream"
#include"map"
#include"string"
#include"queue"
#include"stdlib.h"
#include"math.h"
#define M 110009
#define eps 1e-10
#define inf 1000000000
#define mod 1000000000
#define INF 1000000000
using namespace std;
struct node
{
    int u,v,next;
}edge[M*2];
struct Lnode
{
    int v;
    Lnode(int vv)
    {
        v=vv;
    }
};
vector<Lnode>e[M];
int t,pos,head[M],son[M],fa[M],num[M],top[M],ID,deep[M],p[M],fp[M],px[M];
void init()
{
    t=pos=0;
    memset(head,-1,sizeof(head));
    memset(son,-1,sizeof(son));
    memset(fa,-1,sizeof(fa));
}
void add(int u,int v)
{
    edge[t].u=u;
    edge[t].v=v;
    edge[t].next=head[u];
    head[u]=t++;
}
void dfs(int u,int f,int d)
{
    deep[u]=d;
    fa[u]=f;
    num[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==f)continue;
        dfs(v,u,d+1);
        num[u]+=num[v];
        if(son[u]==-1||num[son[u]]<num[v])
            son[u]=v;
    }
}
void getpos(int u,int sp)
{
    top[u]=sp;
    p[u]=pos++;
    fp[p[u]]=u;
    if(son[u]==-1)return;
    getpos(son[u],sp);
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa[u]||v==son[u])continue;
        getpos(v,v);
    }
}
/**********以上是划分轻重链**************/
struct Tree
{
    int l,r,maxi;
}tree[M*4];
void make(int l,int r,int i)//线段树建树操作
{
    tree[i].l=l;
    tree[i].r=r;
    if(l==r)
    {
        tree[i].maxi=0;
        return ;
    }
    int mid=(l+r)/2;
    make(l,mid,i*2);
    make(mid+1,r,i*2+1);
    tree[i].maxi=max(tree[i*2].maxi,tree[i*2+1].maxi);
}
void updata(int p,int q,int i)//单点更新操作
{
    if(tree[i].l==p&&tree[i].r==p)
    {
        tree[i].maxi=q;
        return;
    }
    int mid=(tree[i].l+tree[i].r)/2;
    if(p<=mid)updata(p,q,i*2);
    else updata(p,q,i*2+1);
    tree[i].maxi=max(tree[i*2].maxi,tree[i*2+1].maxi);
}
void query(int l,int r,int i)//区间查找最大值对应的标，若有多个查找编号最小的记录到ID中
{
    if(tree[i].maxi<tree[1].maxi)
        return;
    if(tree[i].l==tree[i].r)
    {
        if(tree[i].l<ID)
            ID=tree[i].l;
        return;
    }
    int mid=(tree[i].l+tree[i].r)/2;
    if(r<=mid)
        query(l,r,i*2);
    else if(l>mid)
        query(l,r,i*2+1);
    else
    {
        query(l,mid,i*2);
        query(mid+1,r,i*2+1);
    }
}
void Insert(int u,int v,int w)//树与线段树的转化操作
{
    int f1=top[u];
    int f2=top[v];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        e[p[f1]].push_back(Lnode(w));
        e[p[u]+1].push_back(Lnode(-w));
        u=fa[f1];
        f1=top[u];
    }
    if(u==v)
    {
        e[p[u]].push_back(Lnode(w));
        e[p[u]+1].push_back(Lnode(-w));
        return;
    }
    if(deep[u]>deep[v])
        swap(u,v);
    e[p[u]].push_back(Lnode(w));
    e[p[v]+1].push_back(Lnode(-w));
    return;
}
int s[M];
int main()
{
    int n,m,i,j,a,b,c,u,v;
    while(scanf("%d%d",&n,&m),m||n)
    {
        init();
        for(i=0;i<=n;i++)
            e[i].clear();
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        dfs(1,1,1);
        getpos(1,1);
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            Insert(a,b,c);
        }
        make(1,100000,1);
        memset(px,0,sizeof(px));
        for(i=0;i<pos;i++)
        {
            for(j=0;j<(int)e[i].size();j++)
            {
                int v=e[i][j].v;
                if(v>0)
                {
                    px[v]++;
                    updata(v,px[v],1);
                }
                else
                {
                    px[-v]--;
                    updata(-v,px[-v],1);
                }
            }
            if(tree[1].maxi==0)
            {
                 s[fp[i]]=0;
                 continue;
            }
            ID=100000;
            query(1,100000,1);
            s[fp[i]]=ID;
            //printf("%d\n",ID);
        }
        for(i=1;i<=n;i++)
            printf("%d\n",s[i]);
    }
    return 0;
}