HDU 6035 Colorful Tree(dfs)

题意:一棵有n个点的树,树上每个点都有颜色c[i],定义每条路径的值为这条路径上经过的不同颜色数量和。求所有路径的值的和。

可以把问题转化为对每种颜色有多少条不同的路径至少经过这种颜色的点,然后加和。求有多少条路径经过可以转换为总路径数-没有经过的路径数,只要求出没有经过的路径数就好了。

对于每一个相同颜色的点,它们将树割成一些个联通块,显然这些联通块内部之间的路径不会经过这种颜色。

于是问题转化为求点划分的联通块大小。

用类似于虚树的dfs办法,每次维护树上最左边的一段链,然后用栈进行数据的更新即可。

# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <bitset>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define eps 1e-8
# define MOD 1000000007
# define INF 1000000000
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FDR(i,a,n) for(int i=a; i>=n; --i)
# define bug puts("H");
# define lch p<<1,l,mid
# define rch p<<1|1,mid+1,r
# define mp make_pair
# define pb push_back
typedef pair<int,int> PII;
typedef vector<int> VI;
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
inline int Scan() {
    int x=0,f=1; char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘) f=-1; ch=getchar();}
    while(ch>=‘0‘&&ch<=‘9‘){x=x*10+ch-‘0‘; ch=getchar();}
    return x*f;
}
inline void Out(int a) {
    if(a<0) {putchar(‘-‘); a=-a;}
    if(a>=10) Out(a/10);
    putchar(a%10+‘0‘);
}
const int N=200005;
//Code begin...

struct Edge{int p, next;}edge[N<<1];
int head[N], cnt=1;
int node[N], siz[N], num[N], tmp, sum[N], mark;
int st[N<<1], f[N], col[N], pos;
LL ans=0;

void add_edge(int u, int v){edge[cnt].p=v; edge[cnt].next=head[u]; head[u]=cnt++;}
void dfs(int x, int fa){
    siz[x]=1;
    for (int i=head[x]; i; i=edge[i].next) {
        int v=edge[i].p;
        if (v==fa) continue;
        dfs(v,x); siz[x]+=siz[v];
    }
}
void sol(int x, int fa){
    num[x]=siz[x]; --sum[node[x]];
    if (node[x]==node[fa]) --num[x];
    if (col[node[x]]) tmp=st[col[node[x]]], --num[tmp];
    if (fa) {
        if (col[node[fa]]) tmp=st[col[node[fa]]], num[tmp]-=num[x];
        f[++pos]=col[node[fa]]; col[node[fa]]=pos; st[pos]=x;
    }
    for (int i=head[x]; i; i=edge[i].next) {
        int v=edge[i].p;
        if (v==fa) continue;
        sol(v,x);
    }
    if (fa) {
        ans+=(LL)num[x]*(num[x]-1)/2; sum[node[fa]]-=num[x];
        col[node[fa]]=f[col[node[fa]]];
    }
}
void init(){
    mem(head,0); mem(siz,0); mem(num,0); mem(sum,0); mem(col,0); mem(f,0);
    ans=0; mark=0; cnt=1; pos=0;
}
int main ()
{
    int cas=0, n, u, v;
    while (~scanf("%d",&n)) {
        init();
        FOR(i,1,n) scanf("%d",node+i), sum[node[i]]=n;
        FOR(i,1,n) if (sum[i]) ++mark;
        FOR(i,1,n-1) scanf("%d%d",&u,&v), add_edge(u,v), add_edge(v,u);
        dfs(1,0);
        sol(1,0);
        FOR(i,1,n) ans+=(LL)sum[i]*(sum[i]-1)/2;
        ans=(LL)mark*n*(n-1)/2-ans;
        printf("Case #%d: %lld\n",++cas,ans);
    }
    return 0;
}

时间: 2024-10-10 04:37:59

HDU 6035 Colorful Tree(dfs)的相关文章

hdu 6035 Colorful Tree(树形dp+技巧)

题目链接:hdu 6035 Colorful Tree 题意: 给你一棵树,每个节点有一种颜色,现在让你求所有点对的路径上不同的颜色数量的总和. 题解: 下面是官方题解: 单独考虑每一种颜色,答案就是对于每种颜色至少经过一次这种的路径条数之和.反过来思考只需要求有多少条路径没有经过这种颜色即可.直接做可以采用虚树的思想(不用真正建出来),对每种颜色的点按照 dfs 序列排个序,就能求出这些点把原来的树划分成的块的大小.这个过程实际上可以直接一次 dfs 求出. 这里的所说的单独考虑每种颜色,指的

Hdu 5379 Mahjong tree (dfs + 组合数)

题目链接: Hdu 5379 Mahjong tree 题目描述: 给出一个有n个节点的树,以节点1为根节点.问在满足兄弟节点连续 以及 子树包含节点连续 的条件下,有多少种编号方案给树上的n个点编号? 解题思路: 对于一个节点来讲,非叶子儿子节点最多有两个才能满足要求,否则满足子树节点连续的话就无法满足兄弟节点连续.然后有dfs计算每棵子树的贡献值,每棵子树的子节点可以分为叶子节点X和非叶子节点Y,叶子节点可以分配到一组连续的编号,非叶子节点只能分配到兄弟节点中最大或者最小编号两种情况,叶子节

HDU 5379 Mahjong tree(dfs)

题目链接:http://acm.hdu.edu.cn/showproblem.php? pid=5379 Problem Description Little sun is an artist. Today he is playing mahjong alone. He suddenly feels that the tree in the yard doesn't look good. So he wants to decorate the tree.(The tree has n verte

【hdu6035】 Colorful Tree dfs序

题目传送门:http://acm.hdu.edu.cn/showproblem.php?pid=6035 题目大意:给你一棵树,树上每个节点都有一个颜色. 现在定义两点间的距离为两点最短路径上颜色集合大小,求该树上所有点对的距离之和.其中树上的节点个数$≤2*10^5$ 如果直接处理每一条路径上颜色集合大小,显然比较麻烦.我们不妨换一种思路. 我们用S_i表示经过颜色i的路径的数量,显然答案$=\sum S_i$. 考虑如何求S_i.我们先将所有颜色为i的节点全部找出来,按照dfs序排序. 显然

hdu 2489 Minimal Ratio Tree(dfs枚举 + 最小生成树)~~~

题目: 链接:点击打开链接 题意: 输入n个点,要求选m个点满足连接m个点的m-1条边权值和sum与点的权值和ans使得sum/ans最小,并输出所选的m个点,如果有多种情况就选第一个点最小的,如果第一个点也相同就选第二个点最小的........ 思路: 求一个图中的一颗子树,使得Sum(edge weight)/Sum(point weight)最小~ 数据量小,暴力枚举~~~~~dfs暴力枚举C(M,N)种情况. 枚举出这M个点之后,Sum(point weight)固定,进行prim或者K

hdu6035 Colorful Tree 树形dp 给定一棵树,每个节点有一个颜色值。定义每条路径的值为经过的节点的不同颜色数。求所有路径的值和。

/** 题目:hdu6035 Colorful Tree 链接:http://acm.hdu.edu.cn/showproblem.php?pid=6035 题意:给定一棵树,每个节点有一个颜色值.定义每条路径的值为经过的节点的不同颜色数.求所有路径的值和. 思路:看题解后,才想出来的.树形dp. 求所有路径的值和 = 路径条数*总颜色数(n*(n-1)*colors/2)-sigma(每种颜色没有经过的路径条数) 主要是求每种颜色没有经过的路径条数. 画一棵树,我直接用颜色值表示节点编号. 2

hdu 5379 Mahjong tree(树形dp)

题目链接:hdu 5379 Mahjong tree 树形dp,每个节点最多有2个子节点为一棵节点数大于1的子树的根节点,而且要么后代的节点值都大于,要么都小于本身(所以tson不为0是,要乘2).对于K个单一节点的子节点,种类数即为全排K!.当一个节点没有兄弟节点时,以这个节点为根结点的子树,根可以选择最大或者最小. #pragma comment(linker, "/STACK:102400000,102400000") #include <cstdio> #inclu

hdu 1501 Zipper (dfs+记忆化搜索)

Zipper Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6491    Accepted Submission(s): 2341 Problem Description Given three strings, you are to determine whether the third string can be formed

hdu 4601 Letter Tree 2013多校1-2

不容易啊..一个小错误让我wa死了,找了一个晚上,怎么都找不到 最后是对拍代码找到的错误,发现当步数比较小的时候答案就是对的,比较大的时候就不对了 想到一定是什么地方越界了... power[i] = (i64)(power[i - 1] * 26) % mod; 就是这行... 改成  power[i] = ((i64)power[i - 1] * 26) % mod; 就过了... 这道题总的来说就是非常综合,什么方面都涉及一点,核心部分还是把树转化成序列之后二分边界+RMQ,用dfn来确定