hdu - 4303 - Hourai Jeweled 树dp

题意： 给定n（n<=300000）个点的一棵树，每条边有一定的颜色（s<=100000），每个点有点权，如果u->v的路径上相邻的边的颜色都不同那么是一条合法

的路径，求所有合法路径的权值和是多少。http://acm.hdu.edu.cn/showproblem.php?pid=4303

解：

一次dfs就能搞定的问题，其实没什么复杂的算法，主要难点在于统计时的一些小技巧，个人难度评价是偏难的中档题。

从任意一点开始深搜，每颗子树搜索完毕之后向上返回pair<可以延伸到该点且最后一条边与由父节点到该点的边颜色不同的gorgeous边的条数 , 所有这种边分数的总和>

每次深搜完一个子节点之后，增加的过这一点的gorgeous边的总分数为：

之前深搜的所有子节点向上返回的边数之和 * 当前子节点返回的分数 +

之前深搜的所有子节点向上返回的分数之和 * 当前子节点返回的边数 +

之前深搜的所有子节点向上返回的边数之和 * 当前子节点返回的边数 * 当前点的权

用O(n)的时间把所有的累计起来就好了什么的

才没有呢 = =

如果有当前节点分别到两个子节点的边的颜色相同的话也是不行的,

由于数据中添加了度数很大的点，理论上O(儿子数^2)的两两统计也是要被卡掉的 （希望确实的做到了

正确的做法是对所有的儿子按边的颜色排个序，然后在按这个序深搜和统计。

（便捷版解释：为了让当前点可以使用子树得到的数据，需要统计子树中，以子节点为路径起始点，且子节点到它的子节点的边的颜色 与 当前节点到子节点的边的颜色的不同路径的数目和总的价值。
这样，当一棵子树的情况统计完成时，增加的路径为，当前节点与子节点连一条边，或子树间连边。）

呵呵，以上纯为copy，原作者不要见怪。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 300010;


int n;
__int64 nodeValue[MAXN], value[MAXN], number[MAXN];
__int64 ans;
struct Edge
{
    int u, v, c;
}edge[MAXN * 2];
int edgeNumber, head[MAXN];


inline void addEdge(int u, int v, int c)
{
    edge[edgeNumber].u = u;
    edge[edgeNumber].v = v;
    edge[edgeNumber].c = c;
    ++ edgeNumber;
}


bool compare1(const Edge &a, const Edge &b)
{
    return a.u < b.u;
}


bool compare2(const Edge &a, const Edge &b)
{
    return a.c < b.c;
}


void dfs(int x, int father, int fatherColor){
    __int64 lastValue = 0, lastNumber = 0;
    __int64 currentValue = 0, currentNumber = 0;
    int lastColor = - 1;
    value[x] = nodeValue[x];
    number[x] = 1;


    for(int i = head[x]; i != -1 && edge[i].u ==x ; i ++){
        if(edge[i].v == father) continue;
        dfs(edge[i].v , x, edge[i].c);
        if(edge[i].c != lastColor){//在子节点到当前节点的所有边中，如果换了一种新的颜色
            lastNumber = currentNumber;
            lastValue = currentValue;
            lastColor = edge[i].c;
        }
        //如何保证x一定在路径上？ 这就是之前排序的便利了。怪不得之前都初始化为0
        ans += lastNumber * value[edge[i].v];//当前节点x在路径上
        ans += lastValue * number[edge[i].v];
        ans += lastNumber * number[edge[i].v] * nodeValue[x];


        currentValue += value[edge[i].v];
        currentNumber += number[edge[i].v];


        if(fatherColor != edge[i].c){//到达当前节点和（当前节点到父亲节点的边）的颜色不同的边
            number[x] += number[edge[i].v];
            value[x] += value[edge[i].v];
            value[x] += number[edge[i].v] * nodeValue[x];
        }
    }
    if(x != 1){
        ans += number[x] * nodeValue[father];
        ans += value[x];
    }
}


int main()
{
    int u, v, c;
    while(~scanf("%d", &n))
    {
        for(int i=1;i<=n;++i)
        {
            scanf("%I64d", &nodeValue[i]);
        }
        edgeNumber = 0;
        for(int i=1;i<n;++i)
        {
            scanf("%d%d%d", &u, &v, &c);
            addEdge(u, v, c);
            addEdge(v, u, c);
        }
        sort(edge, edge + edgeNumber, compare1);//按起点排序,这样属于一棵子树的就会在一起了。
        memset(head, -1, sizeof(head));
        int start = 0;
        head[edge[0].u] = 0;


        for(int i=1;i<edgeNumber;++i)
        {
            if(edge[i].u != edge[i-1].u)
            {
                sort(edge + start, edge + i, compare2);//对于每课小子树，都自己按颜色排序
                start = i;
                head[edge[i].u] = i;//head[边的起始点] = 边的编号
            }
        }
        ans = 0;
        dfs(1, 0, -1);
        printf("%I64d\n", ans);
    }
    return 0;
}