ZOJ 3824 Fiber-optic Network

Fiber-optic Network

Time Limit: 15000ms

Memory Limit: 262144KB

This problem will be judged on ZJU. Original ID: 3824
64-bit integer IO format: %lld      Java class name: Main

 

one router. These routers are connected by optical cables in such a way that there is exactly one path between any two routers.

Each router should be initialized with an operating frequency Fi before it starts to work. Due to the limitations of hardware and environment, the operating frequency should be an integer number within [Li, Ri]. In order to reduce the signal noise, the operating frequency of any two adjacent routers should be co-prime.

Edward is the headmaster of Marjar University. He is very interested in the number of different ways to initialize the operating frequency. Please write a program to help him! To make the report simple and neat, you only need to calculate the sum of Fi (modulo 1000000007) in all solutions for each router.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains one integer N (1 <= N <= 50). The next line contains N integers Li (1 <= Li <= 50000). Then, the following line contains N integers Ri (Li <= Ri <= 50000).

For the next N - 1 lines, each line contains two integers Xi and Yi. That means there is an optical cable connecting router Xi and router Yi (indexes are 1-based).

Output

For each test case, output a line with N integers representing the sum of Fi (modulo 1000000007) in all solutions.

Sample Input

2
4
1 2 3 4
2 3 4 5
1 2
2 3
3 4
4
1 2 3 4
2 3 4 5
1 2
1 3
1 4

Sample Output

5 10 14 19
10 23 31 41

Hint

In the first sample test case, there are 4 ways to initialize the operating frequency:

• 1 2 3 4
• 1 2 3 5
• 1 3 4 5
• 2 3 4 5

 

Source

The 2014 ACM-ICPC Asia Mudanjiang Regional Contest

Author

JIANG, Kai

 

解题：一道比较重口味的树形dp数论容斥题

 

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 50001;
const int maxm = 51;
const LL mod = 1000000007;
vector<int>p[maxn];
vector<int>g[maxm];
vector<int>fac[maxm][maxn];
bool np[maxn] = {true,true};
int L[maxm],R[maxm];
LL dp[maxm][maxn],multi[maxm][maxn],sum[maxm],ans[maxm];
void init() {
    for(int i = 2; i < maxn; ++i) {
        if(!np[i]) {
            for(int j = i; j < maxn; j += i) {
                np[j] = true;
                p[j].push_back(i);
            }
        }
    }
}
LL quickPow(LL base,LL index,LL mod) {
    LL ret = 1;
    while(index) {
        if(index&1) ret = ret*base%mod;
        base = base*base%mod;
        index >>= 1;
    }
    return ret;
}
LL inv(LL b,LL mod) {
    return quickPow(b,mod-2,mod);
}
void dfs(int u,int fa) {
    for(int i = L[u]; i <= R[u]; ++i) dp[u][i] = 1;
    for(int i = 0; i < g[u].size(); ++i) {
        if(g[u][i] == fa) continue;
        dfs(g[u][i],u);
    }
    for(int j = L[u]; j <= R[u]; ++j) {
            fac[u][j].clear();
        for(int i = 0; i < g[u].size(); ++i) {
            if(g[u][i] == fa) continue;
            LL S = 0;
            for(int k = 1,sz = (1<<p[j].size()); k < sz; ++k) {
                LL tmp = 1;
                int cnt = 0;
                for(int t = 0; t < p[j].size(); ++t) {
                    if((k>>t)&1) {
                        ++cnt;
                        tmp *= p[j][t];
                        if(tmp >= maxn) break;
                    }
                }
                if(tmp < maxn) S = (S + ((cnt&1)?multi[g[u][i]][tmp]:-multi[g[u][i]][tmp]))%mod;
            }
            LL num = ((sum[g[u][i]] - S)%mod + mod)%mod;
            dp[u][j] = dp[u][j]*num%mod;
            fac[u][j].push_back(num);
        }
    }
    sum[u] = 0;
    for(int i = 1; i < maxn; ++i) {
        sum[u] = (sum[u] + dp[u][i])%mod;
        multi[u][i] = 0;
        for(int j = i; j < maxn; j += i)
            multi[u][i] = (multi[u][i] + dp[u][j])%mod;
    }
}
void dfs2(int u,int fa) {
    ans[u] = 0;
    for(int i = L[u]; i <= R[u]; ++i) ans[u] = (ans[u] + dp[u][i]*i)%mod;
    for(int i = 0,c = 0; i < g[u].size(); ++i) {
        if(g[u][i] == fa) continue;
        for(int j = L[u]; j <= R[u]; ++j)
            if(dp[u][j]) dp[u][j] = dp[u][j]*inv(fac[u][j][c],mod)%mod;
        sum[u] = 0;
        for(int k = 1; k < maxn; ++k) {
            multi[u][k] = 0;
            sum[u] = (sum[u] + dp[u][k])%mod;
            for(int j = k; j < maxn; j += k)
                multi[u][k] = (multi[u][k] + dp[u][j])%mod;
        }
        for(int j = L[g[u][i]]; j <= R[g[u][i]]; ++j) {
            LL S = 0;
            for(int k = 1,sz = p[j].size(); k < (1<<sz); ++k) {
                int cnt = 0;
                LL tmp = 1;
                for(int t = 0; t < sz; ++t)
                    if((k>>t)&1) {
                        ++cnt;
                        tmp *= p[j][t];
                        if(tmp >= maxn) break;
                    }
                if(tmp < maxn) S = (S + ((cnt&1)?multi[u][tmp]:-multi[u][tmp]))%mod;
            }
            dp[g[u][i]][j] = dp[g[u][i]][j]*(((sum[u] - S)%mod + mod)%mod)%mod;
        }
        dfs2(g[u][i],u);
        for(int j = L[u]; j <= R[u]; ++j)
            if(dp[u][j]) dp[u][j] = dp[u][j]*fac[u][j][c]%mod;
        ++c;
    }
}
int main() {
    init();
    int kase,n,u,v;
    scanf("%d",&kase);
    while(kase--) {
        scanf("%d",&n);
        for(int i = 1; i <= n; ++i){
            scanf("%d",L + i);
            g[i].clear();
        }
        memset(dp,0,sizeof dp);
        for(int i = 1; i <= n; ++i)
            scanf("%d",R + i);
        for(int i = 1; i < n; ++i) {
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        dfs(1,-1);
        dfs2(1,-1);
        for(int i = 1; i <= n; ++i)
            printf("%lld%c",ans[i],i==n?'
':' ');
    }
    return 0;
}