树形DP与图论算法-优快云博客

本文探讨了几种复杂的树形DP和图论问题解决方法，包括如何通过树形DP和巧妙的数据结构优化来实现高效的算法设计。文章深入介绍了特定问题的解决思路，如寻找最优路径、处理树形结构中的数据依赖等。

bzoj 3522&&4543

这题好神。。。
一开始我还在想启发式合并，然后写了一个发现gg了，然后看题解发现这题正解竟然TM是 $O(n)$ 的！是 $O(n)$ 的！！是 $O(n)$ 的！！！

树形dp。设 $f[i][j]$ 表示在点i，向下长度为j的路径条数。
设 $g[i][j]$ 表示i的子树中和与i距离为j的点可以拼成一个三元组的点对数。就是这样：
这里写图片描述

其中z与i的距离为j。
转移有点麻烦。
这不是 $O(n^2)$ 的吗？
对每个点找一个重儿子，然后先dp那个重儿子。得到f和g。
然后当前点的f和g的初始值为重儿子的f和g分别右移左移一位。
然后再dp其他儿子。

设 $dis[x]$ 为点x能向下最大深度。这样的复杂度是： $(\sum{dis[to[i]]})-dis[son[x]]$ = $(\sum{dis[to[i]]})-dis[x]+1$
加起来之后就是所有叶子的dis和。所以是总复杂度是 $O(n)$ 的。

#include <bits/stdc++.h>
using namespace std;
#define N 110000
#define M 5100000
#define ll long long
int n,tot;
ll g[M],ans;
int f[M],pf[N],pg[N];
int head[N],nex[N<<1],to[N<<1];
int deep[N],md[N],son[N],size[N];
void add(int x,int y)
{
    tot++;
    nex[tot]=head[x];head[x]=tot;
    to[tot]=y;
}
void dfs1(int x,int y)
{
    deep[x]=deep[y]+1;
    md[x]=2;size[x]=1;
    for(int i=head[x];i;i=nex[i])
        if(to[i]!=y)
        {   
            dfs1(to[i],x);
            size[x]+=size[to[i]];
            son[x]=size[to[i]]>size[son[x]] ? to[i]:son[x];
            md[x]=max(md[x],md[to[i]]+1);
        }
}
void dfs(int x,int y)
{
    f[pf[x]]=1;
    if(son[x])
    {
        pf[son[x]]=pf[x]+1;
        pg[son[x]]=pg[x];
        dfs(son[x],x);
        pg[x]=pg[son[x]]+1;
        g[pg[x]-1]=0;
    }
    for(int i=head[x],t;i;i=nex[i])
        if((t=to[i])!=y&&t!=son[x])
        {
            pf[t]=pf[x]+md[x];
            pg[t]=pg[x]+md[x];
            dfs(t,x);
            for(int j=0;j<md[t]-1;j++)
                ans+=g[pg[x]+j+1]*f[pf[t]+j];
            for(int j=2;j<md[t]-1;j++)
                ans+=f[pf[x]+j-1]*g[pg[t]+j];

            for(int j=0;j<md[t]-1;j++)
                g[pg[x]+j+1]+=(ll)f[pf[x]+j+1]*f[pf[t]+j];
            for(int j=0;j<md[t]-1;j++)
                f[pf[x]+j+1]+=f[pf[t]+j];
            for(int j=1;j<md[t]-1;j++)
                g[pg[x]+j-1]+=g[pg[t]+j];

            memset(g+pg[t],0,sizeof(g[0])*md[t]);
            memset(f+pf[t],0,sizeof(f[0])*md[t]);
        }
    ans+=g[pg[x]];
}
int main()
{
    scanf("%d",&n);
    pf[1]=pg[1]=2;
    for(int i=1,x,y;i<n;i++)
    {   
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs1(1,0);
    dfs(1,0);
    printf("%lld\n",ans);
    return 0;
}

bzoj 3827

每个询问处理一遍，双指针求出从一个点开始一步能走到哪里。然后这形成一棵树。然后按深度从大到小扫一遍。每次用并查集把路径上的点并到查询的终点。

#include <bits/stdc++.h>
using namespace std;
#define N 1000010
int n,m,mx;
int a[N],fa[N<<1],deep[N<<1];
int cal(int x)
{
    int t;
    for(t=x;t<x+n;t=fa[t]);
    for(int i=fa[x],j=x;i!=t;j=i,i=fa[i])fa[j]=t;
    return deep[x]-deep[t];
}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),mx=max(mx,a[i]);
    for(int x,l=(n<<1);m--;)
    {
        scanf("%d",&x);
        if(x<mx){puts("NIE");continue;}
        for(int i=1,j=0,sum=0;i<=l;i++)
        {
            while(sum<=x&&j<=l)
            {
                j++;
                sum+=a[j>n ? j-n:j];
            }
            sum-=a[i>n ? i-n:i];fa[i]=j;
        }
        for(int i=l;i>=1;i--)deep[i]=deep[fa[i]]+1;
        int ans=n+1;
        for(int i=1;i<=n;i++)
            ans=min(ans,cal(i));
        printf("%d\n",ans);
    }
    return 0;
}

bzoj 3828

第一眼看错题。。。两个人起点颜色必须相同，且不能选起点。。。
由于每种颜色只出现一次因此可以得到每种颜色的后继。然后扫一遍可以得到每个初始颜色对应的结尾位置。
然后这玩意是单调的。然后扫一遍可以求出每个点右面的所有满足条件的路径中终点最小的。
正着做一遍，对于第二个人反着做一遍。
然后枚举第二个人起点，求最前面颜色相同的点为第一个人起点。
然后用两个最小终点求出一段汇合点的可行区间，将所有区间求一个区间并。
然后区间并中的所有元素都可以是解。

#include <bits/stdc++.h>
using namespace std;
#define N 1100000
int n,m,top,num;
int a[N],st[N],en[N],v[N];
void quit(){puts("0");exit(0);}
struct node
{
    int col[N],cnt,nex[N],pre[N],mn[N];
    void work()
    {
        top=0;
        for(int i=1;i<=cnt;i++)scanf("%d",&v[i]);
        for(int i=1;i<cnt;i++)nex[v[i]]=v[i+1];
        for(int i=n,t;i>=1;i--)
        {
            en[i]=0;
            if(col[i]==v[cnt])en[i]=i;
            else if((t=nex[col[i]])&&pre[t])
                en[i]=en[pre[t]];
            if(col[i]==v[1]&&en[i])st[++top]=i;
            pre[col[i]]=i;
        }
        st[top+1]=1;
        for(int i=1;i<=top;i++)
            for(int j=st[i]-1;j>=st[i+1];j--)
                mn[j]=en[st[i]];
    }
}a1,a2;
struct seg
{
    int l,r;
    seg(){}
    seg(int l,int r):l(l),r(r){}
    friend bool operator < (const seg &r1,const seg &r2)
    {return r1.l<r2.l;};
}b[N];
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
        a1.col[i]=a[i],a2.col[i]=a[n-i+1];
    scanf("%d%d",&a1.cnt,&a2.cnt);
    a1.work();
    a2.work();
    for(int i=1,t,t1,t2;i<=n;i++)
        if(t=a1.pre[a2.col[i]])
        {
            t1=a1.mn[t];t2=a2.mn[i];
            if(t1&&t2&&n-t2+1>=t1)
                b[++num]=seg(t1,n-t2+1);
        }
    sort(b+1,b+1+num);
    int beg=b[1].l,en=b[1].r;top=0;
    for(int i=2;i<=num;i++)
    {
        if(b[i].l>en)
        {
            for(int j=beg;j<=en;j++)
                if(a[j]==v[a2.cnt])st[++top]=j;
            beg=b[i].l;en=b[i].r;
        }
        else en=max(en,b[i].r);
    }
    for(int i=beg;i<=en;i++)
        if(a[i]==v[a2.cnt])st[++top]=i;
    printf("%d\n",top);
    for(int i=1;i<=top;i++)
        printf("%d ",st[i]);
    return 0;
}

bzoj 3829

树形dp，设 $f[i]$ 表示到点i后至少需要多长时间才能修完i的子树， $size[i]$ 表示i子树的大小。
然后假设当前点子树第i个走到的为 $b[i]$
那么这个点的时间为： $f[b[i]]+1+\sum_{j=1}^{i-1}size[b[i]]*2$
然后贪心，按 $f[x]-1-size[x]*2$ 从到大到小的顺序走所有的子树。这个自己证一下吧。。。

#include <bits/stdc++.h>
using namespace std;
#define N 510000
int n,tot;
int a[N],head[N],nex[N<<1],to[N<<1];
int f[N],size[N];
void add(int x,int y)
{
    tot++;
    nex[tot]=head[x];head[x]=tot;
    to[tot]=y;
}
struct node
{
    int x,y;
    node(){}
    node(int x,int y):x(x),y(y){}
    friend bool operator < (const node &r1,const node &r2)
    {return r1.x-r1.y>r2.x-r2.y;};
};
vector<node>v[N];
void dfs(int x,int y)
{
    size[x]=1;f[x]=a[x];
    for(int i=head[x];i;i=nex[i])
        if(to[i]!=y)
        {
            dfs(to[i],x);
            size[x]+=size[to[i]];
            v[x].push_back(node(f[to[i]]+1,size[to[i]]*2));
        }
    sort(v[x].begin(),v[x].end());
    for(int i=0,sum=0;i<v[x].size();i++)
    {
        node t=v[x][i];
        f[x]=max(f[x],t.x+sum);
        sum+=t.y;
    }
}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1,x,y;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs(1,0);
    printf("%d\n",max(f[1],(n-1)*2+a[1]));
    return 0;
}

读入的所有 $a[i]=max(a[i],a[i-1]+1)$ 表示第i辆车最早的发车时间。
设 $f[i]$ 表示车i最早回来的时间。一定是连续的一段车一起去并且一起回来，不会出现其他情况。
然后 $f[i]=min(max(f[j]+i-j-1,a[i])+2s+i-j-1)$
$=min(max(f[j]-j-1,a[i]-i)+2s+2i-j-1)$
然后 $f[j]-j-1$ 单调不减。因此可以二分分界点。
其中 $a[i]+2s+i-j-1$ 一定在分界点处取最小值。
$f[j]+2s+2i-2j-2$ 可以用树状数组维护。

#include <bits/stdc++.h>
using namespace std;
#define N 1100000
#define ll long long
int n,s;
int a[N];
ll f[N],tr[N];
void insert(int x,ll v)
{
    for(int i=x;i<=n+1;i+=i&-i)
        tr[i]=min(tr[i],v);
}
ll query(int x)
{
    ll ret=tr[0];
    for(int i=x;i;i-=i&-i)
        ret=min(ret,tr[i]);
    return ret;
}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d%d",&n,&s);a[0]=-1;
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),a[i]=max(a[i],a[i-1]+1);
    memset(tr,0x3f,sizeof(tr));
    insert(n+1,0);
    for(int i=1;i<=n;i++)
    {
        int l=0,r=i-1;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(f[mid]-mid-1<=a[i]-i)l=mid+1;
            else r=mid-1;
        }
        f[i]=query(n-(r+1)+1)+2*s+2*i-2;
        f[i]=min(f[i],(ll)a[i]+2*s+i-r-1);
        insert(n-i+1,f[i]-2*i);
    }
    printf("%lld\n",f[n]);
    return 0;
}

bzoj 3831

单调队列，设f[i]表示到点i最小花费，维护一个f的单调队列，如果f值相同那么比较高度。

#include <bits/stdc++.h>
using namespace std;
#define N 1100000
int n,h,r,T;
int a[N],f[N],q[N];
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    scanf("%d",&T);
    for(int m;T--;)
    {
        scanf("%d",&m);
        q[h=r=1]=1;
        for(int i=2;i<=n;i++)
        {
            if(q[h]<i-m)h++;
            f[i]=f[q[h]]+(a[q[h]]<=a[i]);
            while(h<=r&&(f[q[r]]>f[i]||(f[q[r]]==f[i]&&a[q[r]]<=a[i])))
                r--;
            q[++r]=i;
        }
        printf("%d\n",f[n]);
    }
    return 0;
}

bzoj 3833

首先由于所有灯的角度都是一样的，所以可以用坐标转换把一个点和点的覆盖区域转成平面直角坐标系里的点和一个点右上的区域。
然后这个问题可以转化为平面上一坨点，设一个点的答案为ans，求一个点左下的点中ans第k小的值。
树套树+二分？
这题 $nlog^2$ 都卡得要死你TM跟我讲这个？

由于求的东西天生离线所以我们可以排序消掉一维坐标。
然后就是带修求前缀第k大。
树状数组套主席树？
这题 $nlog$ 内存都卡的要死你TM跟我讲这个？

那么只能套一个平衡树。
不过如果把坐标套在外面还是直接 $nlog^3$ 手动再见。
不过如果把ans套在外面可以直接在外层树上二分，里层套一个平衡树这样就可以 $nlog^2$ 啦。
不过卡常+卡内存真是蛋疼啊啊啊啊。。。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200010
#define M 4600000
#define ls l,mid,now<<1
#define rs mid+1,r,now<<1|1
#define which(x) ch[fa[x]][1]==x
#define pushup(x) size[x]=size[ch[x][0]]+size[ch[x][1]]+sum[x]
int n,type,cnt,t,tmp;
ll X[N],Y[N],X1[N],Y1[N],K[N];
int ch[M][2],val[M],size[M],fa[M],sum[M];
int pos[N],ans[N];
int cmp(int x,int y)
{
    if(X[x]!=X[y])return X[x]<X[y];
    return Y[x]<Y[y];
}
struct splay_tree
{
    int l,r,v1;
    void init(int &x)
    {
        x=++cnt;val[x]=0;size[x]=2;sum[x]=1;
        val[ch[x][1]=++cnt]=n+1;
        size[ch[x][1]]=1;fa[ch[x][1]]=x;
        sum[ch[x][1]]=1;
    }
    void pre(int x)
    {
        if(!x)return;
        if(val[x]<v1)
            l=x,pre(ch[x][1]);
        else pre(ch[x][0]);
    }
    void nex(int x)
    {
        if(!x)return;
        if(val[x]>v1)
            r=x,nex(ch[x][0]);
        else nex(ch[x][1]);
    }
    int find(int x)
    {
        if(!x)return 0;
        if(val[x]<=v1)
            return size[ch[x][0]]+sum[x]+find(ch[x][1]);
        return find(ch[x][0]);
    }
    void rotate(int x)
    {
        int y=fa[x],k=which(x);
        ch[y][k]=ch[x][k^1];
        ch[x][k^1]=y;
        ch[fa[y]][which(y)]=x;

        fa[x]=fa[y];fa[y]=x;
        fa[ch[y][k]]=y;
        pushup(y);pushup(x);
    }
    void splay(int x,int y,int &root)
    {       
        while(fa[x]!=y)
        {
            int t=fa[x];
            if(fa[t]==y)rotate(x);
            else
            {
                if(which(x)^which(t))rotate(x);
                else rotate(t);
                rotate(x);
            }
        }
        if(!y)root=x;
    }
    int query(int &x,int v)
    {
        v1=v;
        if(type)
        {
            pre(x);splay(l,0,x);
            nex(x);splay(r,l,x);
            return size[ch[r][0]];
        }
        return find(x)-1;
    }
    void insert(int &x,int v)
    {
        int tar=x,t1=x;
        while(t1)
        {
            if(val[t1]==v)
            {
                sum[t1]++;splay(t1,0,x);
                return;
            }
            if(val[t1]<v)tar=t1,t1=ch[t1][1];
            else tar=t1,t1=ch[t1][0];
        }
        ch[tar][v>val[tar]]=++cnt;
        fa[cnt]=tar;val[cnt]=v;
        sum[cnt]=size[cnt]=1;
        splay(cnt,0,x);
    }
}tr2;
struct seg_tree
{       
    int root[N<<2];
    void build(int l,int r,int now)
    {
        tr2.init(root[now]);
        if(l==r)return;
        int mid=(l+r)>>1;
        build(ls);build(rs);
    }
    int query(int l,int r,int now,int k)
    {
        if(l==r)return l;
        int t1=tr2.query(root[now<<1],Y[t]);
        int mid=(l+r)>>1;
        if(t1>=k)return query(ls,k);
        else return query(rs,k-t1);
    }
    void insert(int l,int r,int now,int v)
    {
        tr2.insert(root[now],v);
        if(l==r)return;
        int mid=(l+r)>>1;
        if(ans[t]<=mid)insert(ls,v);
        else insert(rs,v);
    }
}tr1;
char getc()
{
    static const int LEN = 4096;
    static char buf[LEN],*S=buf,*T=buf;
    if(S == T)
    {
        T = (S=buf)+fread(buf,1,LEN,stdin);
        if(S == T)return EOF;
    }
    return *S++;
}
int read()
{
    static char ch;
    static int D,type;
    type=0;
    while(!isdigit(ch=getc()))type|=(ch=='-');
    for(D=ch-'0'; isdigit(ch=getc());)
        D=(D<<3)+(D<<1)+(ch-'0');
    return type ? -D:D;
}
void print(int x)
{
    if(!x)return;
    print(x/10);
    putchar(x%10+'0');
}
int main()
{
    n=read();
    ll x1,x2,y1,y2;
    x1=read();y1=read();x2=read();y2=read();
    if(type=(x1*y2==x2*y1))x2=-y1,y2=x1;
    int tt= x1*y2-x2*y1>0 ? -1:1; 
    for(int i=1,x,y;i<=n;i++)
    {
        x=read();y=read();
        X1[i]=X[i]=(x2*y-y2*x)*tt;
        Y1[i]=Y[i]=(y1*x-x1*y)*tt;
    }
    sort(X1+1,X1+1+n);
    sort(Y1+1,Y1+1+n);
    int sx=unique(X1+1,X1+1+n)-X1-1;
    int sy=unique(Y1+1,Y1+1+n)-Y1-1;
    for(int i=1;i<=n;i++)
    {
        K[i]=read();
        X[i]=lower_bound(X1+1,X1+1+sx,X[i])-X1;
        Y[i]=lower_bound(Y1+1,Y1+1+sy,Y[i])-Y1;
        pos[i]=i;
    }
    sort(pos+1,pos+1+n,cmp);
    tr1.build(1,n,1);
    for(int i=1;i<=n;i++)
    {
        t=pos[i];
        if(tr2.query(tr1.root[1],Y[t])<K[t])ans[t]=t;
        else 
        {
            ans[t]=tr1.query(1,n,1,K[t]);
            ans[t]=min(ans[t],t);
        }
        tr1.insert(1,n,1,Y[t]);
    }
    for(int i=1;i<n;i++)
        print(ans[i]),putchar(' ');
    print(ans[n]);
    return 0;
}

bzoj 3835

我搞出来的结论是优先取能取的子树最大的点。不过并没有什么卵用。。。
首先这题有一个迷之结论： $ans=max(i+\lceil \frac{sum[i]}{k}\rceil)$ 其中 $0\le i\le max(deep)$ 。化一下变成 $max(\lceil \frac{sum[i]+ki}{k}\rceil)$ 然后就可以斜率优化了。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1100000
int n,m,h,r,mx;
int a[N],pos[N],fa[N],deep[N],sum[N],q[N],ans[N];
int cmp(int x,int y){return a[x]>a[y];}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d",&a[i]),pos[i]=i;
    sort(pos+1,pos+1+m,cmp);
    for(int i=2;i<=n;i++)scanf("%d",&fa[i]);
    for(int i=1;i<=n;i++)
        deep[i]=deep[fa[i]]+1,sum[deep[i]-1]++,mx=max(mx,deep[i]);
    for(int i=n;i>=1;i--)sum[i]+=sum[i+1];
    q[h=r=1]=mx;
    for(int i=mx-1;i>=0;i--)
    {
        while(r>h&&(ll)(sum[i]-sum[q[r]])*(q[r-1]-q[r])>=(ll)(sum[q[r]]-sum[q[r-1]])*(q[r]-i))
            r--;
        q[++r]=i;
    }
    for(int i=1,t;i<=m;i++)
    {
        t=pos[i];
        while(r>h&&(ll)a[t]*q[h]+sum[q[h]]<=(ll)a[t]*q[h+1]+sum[q[h+1]])
            h++;
        ans[t]=((ll)a[t]*q[h]+sum[q[h]]-1)/a[t]+1;
    }
    for(int i=1;i<m;i++)
        printf("%d ",ans[i]);
    printf("%d\n",ans[m]);
    return 0;
}

bzoj 3836

感觉挺妙的。
由于没有长度超过10的简单路径，所以dfs树的深度不超过10。
然后树形dp，不过由于这里每个点取不取和返祖边指向的点有关，因此我们需要记录一下祖先的状态。可以用三进制记录一个点。0表示这个点取，1表示这个点不取且相邻的点也没有取，2表示这个点不取但相邻的点取。
状压一个点的所有祖先的状态作为该点的状态。
转移时先用父亲已经被搜过的其他儿子更新过的状态更新该点的状态。该点搜完之后再用这个点来更新父亲的状态。

#include <bits/stdc++.h>
using namespace std;
#define N 21000
#define M 51000
const int inf=1e9;
int n,m,tot,top,ans;
int a[N],head[N],deep[N],st[N];
int nex[M],to[M];
int p[12],f[12][61000];
void add(int x,int y)
{
    tot++;
    nex[tot]=head[x];head[x]=tot;
    to[tot]=y;
}
void dfs(int x)
{
    int d=deep[x];
    if(d==1)f[1][0]=a[x],f[1][1]=0,f[1][2]=inf;
    else
    {
        top=0;
        for(int i=head[x];i;i=nex[i])
            if(deep[to[i]])
                st[++top]=deep[to[i]]-1;
        for(int i=0;i<p[d];i++)f[d][i]=inf;
        for(int i=0;i<p[d-1];i++)
        {
            int type=1,v=i;
            for(int j=1,t;j<=top;j++)
            {   
                if((t=i/p[st[j]]%3)==0)type=2;
                else if(t==1)v+=p[st[j]];
            }
            f[d][i+p[d-1]*type]=min(f[d][i+p[d-1]*type],f[d-1][i]);
            f[d][v]=min(f[d][v],f[d-1][i]+a[x]);
        }
    }
    for(int i=head[x];i;i=nex[i])
        if(!deep[to[i]])
        {
            deep[to[i]]=d+1;
            dfs(to[i]);
            for(int j=0;j<p[d];j++)
                f[d][j]=min(f[d+1][j],f[d+1][j+p[d]*2]);
        }
}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    p[0]=1;
    for(int i=1;i<=10;i++)p[i]=p[i-1]*3;
    for(int i=1,x,y;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    for(int i=1;i<=n;i++)
        if(!deep[i])
        {
            deep[i]=1;dfs(i);
            ans+=min(f[1][0],f[1][2]);
        }
    printf("%d\n",ans);
    return 0;
}

bzoj 3872

从这条边的两个端点分别往两边dfs，一个叶节点维护每一个往上的 $\prod(度数-1)$ 。然后把这个值放在一起排个序。
把所有群的数量排个序。对于每个值然后取得区间是单调的。

#include <bits/stdc++.h>
using namespace std;
#define N 1100000
#define ll long long
int n,m,K,f1,f2,tot,mx,top;
int a[N],head[N],nex[N<<1],to[N<<1];
int du[N],st[N];
ll ans;
void add(int x,int y)
{
    tot++;
    nex[tot]=head[x];head[x]=tot;
    to[tot]=y;
}
void dfs(int x,int y,ll v)
{
    v=min(v,(ll)mx);
    if(du[x]==1)st[++top]=v;
    for(int i=head[x];i;i=nex[i])
        if(to[i]!=y)
            dfs(to[i],x,v*(du[x]-1));
}
int main()
{
    //freopen("tt.in","r",stdin);
    scanf("%d%d%d",&n,&m,&K);
    for(int i=1;i<=m;i++)
        scanf("%d",&a[i]);
    sort(a+1,a+1+m);mx=a[m]+1;
    for(int i=1,x,y;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        if(i==1)f1=x,f2=y;
        add(x,y);add(y,x);
        du[x]++;du[y]++;
    }
    dfs(f1,f2,1);
    dfs(f2,f1,1);
    sort(st+1,st+1+top);
    int h=1,r=0;
    for(int i=1;i<=top;i++)
    {
        while(r<m&&a[r+1]/st[i]<=K)r++;
        while(h<=m&&a[h]/st[i]<K)h++;
        ans+=(ll)K*(r-h+1);
    }
    printf("%lld\n",ans);
    return 0;
}