2020牛客寒假算法基础集训营1 F-maki和tree

链接：https://ac.nowcoder.com/acm/contest/3002/F
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述

有一天，maki拿到了一颗树。所谓树，即没有自环、重边和回路的无向连通图。
这个树有 个顶点， 条边。每个顶点被染成了白色或者黑色。
maki想知道，取两个不同的点，它们的简单路径上有且仅有一个黑色点的取法有多少？
注：
①树上两点简单路径指连接两点的最短路。
② 和 的取法视为同一种。

 

 

 

输入描述:

第一行一个正整数n。代表顶点数量。

第二行是一个仅由字符'B'和'W'组成的字符串。第 i个字符是B代表第 i 个点是黑色，W代表第 i个点是白色。

接下来的n-1行，每行两个正整数 x ， y，代表 x 点和 y点有一条边相连 

输出描述:

一个正整数，表示只经过一个黑色点的路径数量。

示例1

输入

复制

3
WBW
1 2
2 3

输出

复制

3

说明

树表示如下：

其中只有2号是黑色点。

<1,2>、<2,3>、<1,3>三种取法都只经过一个黑色点。

 

思路：

　　　对于可以连边的白色节点，用并查集把节点合并，并且在合并时更新连通块大小。

　　　对于一条含有黑色节点的路径，我们易知：路径数 = 黑色节点相邻的 白连通块内点的size * 该点相连的白连通块点的size···

　　　

　　　所以只需要先求出白连通块的大小，然后对于黑点，只需要计算出黑点相邻白连通块加上其的后继连通块即可。

　　　后继白连通块大小求法：

　　　

 　　　关于_find中为什么是sum += sz[r2]的问题，因为建的是无向图，不保证此时的fa[r1]一定是与fa[r2]相等的

　　

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl

using namespace std;
typedef long long LL;
const int maxn = 1e6 + 7;

int n;
LL ans;
int fa[maxn];
int a[maxn];
int head[maxn];
char c[maxn];
int cnt = 0;
LL sz[maxn];
LL num[maxn];
int _count = 0;

//vector <int> g[maxn];

struct Edge {
    int to,nxt;
}edge[maxn];

void BuildGraph(int u, int v) {
    edge[cnt].to = v;
    edge[cnt].nxt = head[u];
    head[u] = cnt++;

    edge[cnt].to = u;
    edge[cnt].nxt = head[v];
    head[v] = cnt++;
}

void init()
{
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= n; i++) {
        fa[i] = i;
        sz[i] = 1;
    }
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int read() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

int fid(int x)
{
    int r = x;
    while(fa[r] != r) {
        r = fa[r];
    }
    int i,j;///路径压缩
    i = x;
    while(fa[i] != r) {
        j = fa[i];
        fa[i] =  r;
        i = j;
    }
    return r;
}

void join(int r1,int r2)///合并
{
    int fidroot1 = fid(r1), fidroot2 = fid(r2);
    int root = min(fidroot1, fidroot2);
    sz[root] = sz[fidroot1] + sz[fidroot2];
    if(fidroot1 != fidroot2) {
        fa[fidroot2] = root;
        fa[fidroot1] = root;
    }
}

LL _find(int x) {
    //dbg(x);
    LL sum = 0;
    for(int i = head[x]; ~i; i = edge[i].nxt) {
        int v = edge[i].to;
        if(a[v]) {
            //num[v] = 0;
            continue;
        }
        int r1 = fid(x), r2 = fid(v);
        sum += sz[r2];
        num[++_count] = sz[r2];
    }
    return sum;
}

int main()
{
    scanf("%d
",&n);
    init();
    ans = 0;
    scanf("%s",c);
    for(int i = 0; i < n; ++i) {
        if(c[i] == 'W') {
            a[i+1] = 0;
        }
        else {
            a[i+1] = 1;
        }
    }
    for(int i = 1; i < n; ++i) {
        int x, y;
        scanf("%d %d",&x, &y);
        BuildGraph(x,y);
        if(!a[x] && !a[y]) {
            join(x,y);
        }
    }
    for(int i = 1; i <= n; ++i) {
        if(a[i] == 0) continue;
        _count = 0;
        memset(num, 0, sizeof(num));
        ans += _find(i);
        for(int j = 1; j <= _count; ++j) {
            for(int k = j+1; k <= _count; ++k) {
                ans += num[j] * num[k];
            }
        }
    }

    printf("%lld
",ans);
}