[CF486D]Valid Sets

题目

传送门

题解

DP 矮子又来学习 DP 了

代码短小精悍思路十分巧妙的树形 \(DP\).

在一般的树 \(DP\) 中，我们一般都会对子树树根进行一些限定，并使其有主导作用，这样才能避免重复，在这道题中，我们不妨假定我们的树根为 最大/最小 的（两种思路皆可），这里假定我们选定的某一个树根是最小的.

显然，每个点作为树根，其方案都是不一样的（因为最小值都不一样），那么我们要对所有点分别进行 \(DP\).

因为我们要保证所选的树根的 \(a\) 最小，所以我们拓展出去的点必须保证 \(a[v]\ge a[rt]\)，否则我们这个树根将变得不合法.

注意，当 \(a[v]=a[rt]\) 时，由于我们会统计最后的总方案数，在树根为 \(rt\) 时我们会统计到这个方案，但是在树根换成 \(v\) 之后，我们还会再次统计这个方案，这就造成重复统计方案，为避免这种情况，我们钦定在 \(a[v]=a[rt]\) 时，只有当 \(rt>v\) 才进行拓展

在说完这些细节之后，我们考虑如何进行 \(DP\).

定义 \(f[u]\) 为在根为 \(rt\) 时（这个 \(rt\) 会在 \(Dfs\) 过程中传下去），在 \(u\) 的子树中有多少种合法的联通子图.

考虑 \(f[u]\) 从 \(f[v] (v\in \text{son}_u)\) 计算出，首先，如果我们要拓展到 \(v\)，需要保证的是 \(a[v]>a[rt]\) 或者 \(a[v]=a[rt]\) 且 \(rt>v\) （至于为什么前面说过），再者，题目中还有 \(d\) 的限制，所以我们还需要保证 \(a[v]-a[rt]\le d\)，在这些条件都满足下，可以进行以下转移：

Dfs(v,u,rt);
f[u]+=1ll*f[u]*f[v]%MOD;
if(f[u]>=MOD)f[u]-=MOD;

转移时使用了乘法原理，不作过多解释.

在访问到一个点时，它单独是必然可行的，所以当访问到一个新点，需要对 \(f[u]\) 赋值为 \(1\) 表示它自己单独是一个连通块.

代码

#include<cstdio>
#include<cstring>

#define rep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i<=i##_end_;++i)
#define fep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i>=i##_end_;--i)
#define erep(i,u) for(signed i=tail[u],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define writc(a,b) fwrit(a),putchar(b)
#define mp(a,b) make_pair(a,b)
#define ft first
#define sd second
typedef long long LL;
// typedef pair<int,int> pii;
typedef unsigned long long ull;
typedef unsigned uint;
#define Endl putchar('\n')
// #define int long long
// #define int unsigned
// #define int unsigned long long

#define cg (c=getchar())
template<class T>inline void read(T& x){
    char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    if(f)x=-x;
}
template<class T>inline T read(const T sample){
    T x=0;char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    return f?-x:x;
}
template<class T>void fwrit(const T x){//just short,int and long long
    if(x<0)return (void)(putchar('-'),fwrit(-x));
    if(x>9)fwrit(x/10);
    putchar(x%10^48);
}
template<class T>inline T Max(const T x,const T y){return x>y?x:y;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
inline int gcd(const int a,const int b){return b?gcd(b,a%b):a;}
inline void getInv(int inv[],const int lim,const int MOD){
    inv[0]=inv[1]=1;for(int i=2;i<=lim;++i)inv[i]=1ll*inv[MOD%i]*(MOD-MOD/i)%MOD;
}
inline LL mulMod(const LL a,const LL b,const LL mod){//long long multiplie_mod
    return ((a*b-(LL)((long double)a/mod*b+1e-8)*mod)%mod+mod)%mod;
}

const int MAXN=2000;
const int MOD=1e9+7;

int a[MAXN+5],n,d;

struct edge{int to,nxt;}e[MAXN*2+5];
int tail[MAXN+5],ecnt;
inline void add_edge(const int u,const int v){
    e[++ecnt]=edge{v,tail[u]};tail[u]=ecnt;
    e[++ecnt]=edge{u,tail[v]};tail[v]=ecnt;
}

inline void Init(){
    d=read(1),n=read(1);
    rep(i,1,n)a[i]=read(1);
    rep(i,1,n-1)add_edge(read(1),read(1));
}

int f[MAXN+5],ans;
void Dfs(const int u,const int fa,const int rt){
    // printf("Now u == %d, fa == %d, rt == %d\n",u,fa,rt);
    f[u]=1;
    erep(i,u)if(v!=fa){
        if(a[rt]>a[v] || (a[rt]==a[v] && rt>v)){
            if(a[rt]-a[v]<=d){
                Dfs(v,u,rt);
                f[u]+=1ll*f[u]*f[v]%MOD;
                if(f[u]>=MOD)f[u]-=MOD;
            }
        }
    }return;
}

signed main(){
    Init();
    int ans=0;
    rep(i,1,n){
        Dfs(i,0,i);
        ans+=f[i];
        if(ans>=MOD)ans-=MOD;
    }writc(ans,'\n');
    return 0;
}