HDU 5739 Fantasia 双连通分量 树形DP
题意:
给出一个无向图,每个顶点有一个权值\(w\),一个连通分量的权值为各个顶点的权值的乘积,一个图的权值为所有连通分量权值之和。
设删除顶点\(i\)后的图\(G_i\)的权值为\(z_i\),求\(\sum i \times z_i \; mod \; 10^9 + 7\)。
分析:
这里找到了一篇论文,借其中的图说明一下:
左图为原图,首先找出所有的点双连通分量(一种颜色对应一个双连通),然后重新建一个图(右图):
对每个双连通加一个点,然后对这个新点和双连通中所有的点连边(正方形对应原图中的点,圆形对应新加的点)。
这样就得到了一个森林(block forest),因为一个双连通建了一颗树,而不同双连通之间通过割点连通。
所以,原图中的割点都是非叶子节点,其他点都是叶子节点。
将每个新点的权值设为\(1\),这样就不影响原来连通分量的权值。
删除点\(u\)后,\(G_u\)的权值为\(\sum f(v_i)\),其中点\(v_i\)与点\(u\)相邻,\(f(v_i)\)为所在连通分量的权值。
对每棵树任选一个新点作为根,计算\(dp(u)\)为以\(u\)为根的子树的权值,然后再一遍\(DFS\)就可以\(O(n)\)计算删除每个点后的权值。
注意:只有一个点的树需要单独处理。
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
using std::pair;
using std::vector;
using std::stack;
const int maxn = 200000 + 10;
const int MOD = 1000000007;
typedef pair<int, int> Edge;
typedef long long LL;
LL mul(LL a, LL b) { return a * b % MOD; }
void add(LL& a, LL b) { a += b; if(a >= MOD) a -= MOD; }
LL sub(LL a, LL b) { b = MOD - b; a += b; if(a >= MOD) a -= MOD; return a; }
LL pow_mod(LL a, int p) {
LL ans = 1;
while(p) {
if(p & 1) ans = mul(ans, a);
a = mul(a, a);
p >>= 1;
}
return ans;
}
LL div(LL a, LL b) { return mul(a, pow_mod(b, MOD - 2)); }
int n, m, cc_cnt;
int w[maxn * 2];
bool vis[maxn * 2];
vector<int> G[maxn * 2], bcc[maxn], single;
int dfs_clock, bcc_cnt;
int pre[maxn], bccno[maxn];
stack<Edge> S;
int dfs(int u, int fa) {
int lowu = pre[u] = ++dfs_clock;
int child = 0;
for(int v : G[u]) {
Edge e(u, v);
if(!pre[v]) {
S.push(e);
child++;
int lowv = dfs(v, u);
lowu = std::min(lowu, lowv);
if(lowv >= pre[u]) {
bcc_cnt++; bcc[bcc_cnt].clear();
for(;;) {
Edge t = S.top(); S.pop();
int &x = t.first, &y = t.second;
if(bccno[x] != bcc_cnt) { bcc[bcc_cnt].push_back(x); bccno[x] = bcc_cnt; }
if(bccno[y] != bcc_cnt) { bcc[bcc_cnt].push_back(y); bccno[y] = bcc_cnt; }
if(x == u && y == v) break;
}
}
} else if(pre[v] < pre[u] && v != fa) {
S.push(e);
lowu = std::min(lowu, pre[v]);
}
}
if(fa < 0 && !child) single.push_back(u);
return lowu;
}
void find_bcc() {
memset(pre, 0, sizeof(pre));
memset(bccno, 0, sizeof(bccno));
single.clear();
dfs_clock = bcc_cnt = 0;
for(int i = 0; i < n; i++) if(!pre[i]) {
dfs(i, -1);
cc_cnt++;
}
}
void rebuild() {
for(int i = 0; i < n + bcc_cnt; i++) G[i].clear();
for(int i = 0; i < bcc_cnt; i++) {
int u = n + i; G[u].clear();
w[u] = 1;
for(int v : bcc[i + 1]) {
G[u].push_back(v);
G[v].push_back(u);
}
}
}
vector<int> root;
LL d[maxn * 2];
void dp(int u) {
d[u] = w[u];
vis[u] = true;
for(int v : G[u]) if(!vis[v]) {
dp(v);
d[u] = mul(d[u], d[v]);
}
}
LL ans[maxn], sum;
void solve(int u, int fa, LL prod) {
ans[u] = 0;
for(int v : G[u]) if(v != fa) {
solve(v, u, prod);
if(u < n) add(ans[u], d[v]);
}
if(u < n) add(ans[u], div(prod, d[u]));
add(ans[u], sub(sum, prod));
}
int main()
{
int T; scanf("%d", &T);
while(T--) {
scanf("%d%d", &n, &m);
for(int i = 0; i < n; i++) {
scanf("%d", w + i);
G[i].clear();
}
while(m--) {
int u, v; scanf("%d%d", &u, &v);
u--; v--;
G[u].push_back(v);
G[v].push_back(u);
}
find_bcc();
rebuild();
memset(vis, false, sizeof(vis));
root.clear();
sum = 0;
for(int u : single) add(sum, w[u]);
for(int i = 0; i < bcc_cnt; i++) {
int r = n + i; if(!vis[r]) {
root.push_back(r);
dp(r);
add(sum, d[r]);
}
}
memset(ans, 0, sizeof(ans));
for(int r : root) solve(r, -1, d[r]);
LL res = 0;
for(int u : single)
ans[u] = sub(sum, w[u]);
for(int i = 0; i < n; i++) add(res, mul(ans[i], i + 1));
printf("%lld\n", res);
}
return 0;
}