洛谷——P3914 染色计数

P3914 染色计数

题目描述

有一颗NN个节点的树，节点用1,2,\cdots,N1,2,⋯,N编号。你要给它染色，使得相邻节点的颜色不同。有MM种颜色，用1,2,\cdots,M1,2,⋯,M编号。每个节点可以染MM种颜色中的若干种，求不同染色方案的数量除以(10^9 + 7109+7)的余数。

输入输出格式

输入格式：

第1 行，2 个整数N,MN,M。

接下来NN行，第ii行表示节点ii可以染的颜色。第1个整数k_iki​，表示可以染的颜色数量。接下来k_iki​个整数，表示可以染的颜色编号。

最后N - 1N−1行，每行2个整数A_i,B_iAi​,Bi​，表示边(A_i,B_i)(Ai​,Bi​)。

输出格式：

1 个整数，表示所有的数。

输入输出样例

输入样例#1： 复制

2 2
1 1
2 1 2
1 2

输出样例#1： 复制

1

说明

• 对于30% 的数据，1 \le N \le 10; 1 \le M \le 41≤N≤10;1≤M≤4；

• 对于60% 的数据，1 \le N \le 200; 1 \le M \le 2001≤N≤200;1≤M≤200；

• 对于100% 的数据，1 \le N \le 5000; 1 \le M \le 50001≤N≤5000;1≤M≤5000。

dfs+组合数学 爆零、、（可能是我写的问题）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 5100
#define LL long long
#define mod 1000000007
using namespace std;
long long ans;
bool vis[N],vist[N],boo[N][N];
int n,m,x,y,tot,k[N],head[N],a[N][N],same[N][N];
int read()
{
    ,f=; char ch=getchar();
    ;ch=getchar();}
    +ch-',ch=getchar();
    return x*f;
}
struct Edge
{
    int to,next;
}edge[N];
int add(int x,int y)
{
    tot++;
    edge[tot].to=y;
    edge[tot].next=head[x];
    head[x]=tot;
}
int dfs(int x)
{
    for(int i=head[x];i;i=edge[i].next)
    {
        int t=edge[i].to;
        if(!vis[t])
        {
            vis[t]=true;
            if(!vist[t])
            {
                vist[t]=true;
                ans=(ans%mod+1ll*(k[x]-same[x][t])*k[t]%mod+(1ll*same[x][t]*(k[t]-)%mod))%mod;
            }
            dfs(t);
            vis[t]=false;
        }
    }
}
int main()
{
    n=read(),m=read();
    ;i<=n;i++)
    {
        k[i]=read();
        ;j<=k[i];j++)
         a[i][j]=read(),boo[i][a[i][j]]=true;
     }
    ;i<n;i++)
    {
        x=read(),y=read();
        add(x,y),add(y,x);
        ;j<=k[y];j++)
          if(boo[x][a[y][j]])
           same[x][y]++,same[y][x]++;
    }
    vist[]=);
    printf("%lld",ans);
    ;
}

0分代码

不会做了，粘个题解

令f[i][j]f[i][j]表示以ii为根的这棵子树在ii为颜色jj的时候的方案数，根据乘法原理可得f[i][j]=πf[k][c]f[i][j]=πf[k][c] 其中kk是ii的所有儿子，cc是所有与jj不同的颜色。

因此我们可以很容易相处一个O(n^3)O(n3)的是算法：枚举所有点，枚举它的颜色，枚举每一个儿子，枚举儿子的颜色，因为一个点只有一个父亲，所以枚举儿子的那一层加上枚举每一个点一共是O(n)O(n)的。

回过头来再看数据n<=5000n<=5000,m<=5000m<=5000，上述的算法似乎运行起来很吃力。那我们需要向一个办法去将复杂度变成O(n^2)O(n2)，仔细思考后我们会发现，其实枚举儿子那一层是没有必要的，因为我只要颜色不相同的总数，与其O(m)O(m)地去求和，不如之前在枚举到它的时候就处理好所有的和，然后O(1)O(1)地去剪掉这个颜色，从而求出除去这个颜色外的方案数，达到O(n^2)O(n2)的复杂度。

这道题还是很不错的，这种思想在很多时候都能用得上。

# include <algorithm>
# include <iostream>
# include <cstring>
# include <cstdio>
# include <vector>
# include <cmath>
# define R register
# define mod 
 
using namespace std;
 
][],h[],tot[],sum[],x,y,d;
];
 
inline void in(R int &a){
    R , f=;
    ; c = getchar();}
    )+(x<<)+c-',c = getchar();
    a=x*f;
}
 
inline void add(R int x,R int y){
    ed[++e] = (pp){y,h[x]};
    h[x] = e;
}
 
inline void dfs(R int fa,R int x){//树形DP一般用DFS来实现
    for(R int i=h[x]; i; i=ed[i].pre)
    {
        R int p = ed[i].v;
        if(p == fa) continue;
        dfs(x,p);
    }
    ; j<=m; ++j)
    {
        if(!f[x][j]) continue;//没有这种颜色
        for(R int i=h[x]; i; i=ed[i].pre)
        {
            R int p = ed[i].v;
            if(p == fa) continue;
            f[x][j] = 1LL*f[x][j]*(tot[p]-f[p][j])%mod;
        }
        ) f[x][j] += mod;//上边(tot[p]-f[p][j])可能会变成负数，这里把它变回来。
        tot[x] = (1LL*tot[x]+1LL*f[x][j])%mod;
    }
}
 
inline int yg(){
    in(n),in(m);
    ; i<=n; ++i)
    {
        in(sum[i]);
        ; j<=sum[i]; ++j) in(d),f[i][d]++;
    }
    ; i<n; ++i)
    {
        in(x),in(y);
        add(x,y),add(y,x);
    }
    add(,);//为了好写，新建一个原点连向1，这样就不用额外求tot[1]了
    dfs(,);
    cout << tot[];//tot[1]就是最终的答案
}
 
int youngsc = yg();
int main(){;}