Codeforces 700B 友好城市（树形dp）

感觉现在的我还比较难想到这个思路啊。

距离累加和，是由边决定的，所以我们计算每条边的贡献。
可以知道，对于一条边e，如果起点端有 x 个友好城市，终点端有 y 个友好城市，那么这条边的最大贡献就是 min( x,y )，因为少的那端怎么样也只有x个，再没法提供城市给另一端匹配了。

至于如何求一端的友好城市数，实际上就是求子集（当然子节点应该是友好城市才能计数）大小，因为这端是 x ，那另一端肯定是 ( ( k<<1 )-x )。问题就转化为一个很基本的树形dp套路了，用我参考的那篇题解的话说，就是绝世傻题。

const int maxn=200010;

int n,k;
bool node_[maxn];
struct edge
{
    int y,next;
    bool f;
}e[maxn<<1];
int link_[maxn];
int tot_;

int f[maxn];
bool vis[maxn];

long long ans;

void init()
{
    read(n);read(k);
    k=k<<1;
    tot_=0;
    int x,y;
    memset(node_,0,sizeof(node_));
    for(int i=1;i<=k;++i) read(x),node_[x]=1;
    for(int i=1;i<n;++i)
    {
        read(x);read(y);
        insert(x,y);
        insert(y,x);
    }
}

inline void insert(int x,int y)
{
    e[++tot_].y=y;
    e[tot_].next=link_[x];link_[x]=tot_;
}

void work_dp()
{
    memset(f,0,sizeof(f));
    memset(vis,0,sizeof(vis));
    dfs_dp(1);
    ans=0LL;
    memset(vis,0,sizeof(vis));
    dfs_result(1);
    printf("%lld",ans);
}

void dfs_dp(int x)
{
    vis[x]=1;
    for(int i=link_[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            dfs_dp(e[i].y);
            f[x]+=f[e[i].y];
        }
    if(node_[x]) ++f[x];//如果是x友好城市，就可以因为本身的存在++了。
}

void dfs_result(int x)
{
    vis[x]=1;
    for(int i=link_[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            ans+=min(f[e[i].y],k-f[e[i].y]);
            dfs_result(e[i].y);
        }
}

函数顺序是乱的。

OUO