[CodeForces-375E]Red and Black Tree

题目大意：
　　给你一棵带边权的树，每个结点可能是红色或者黑色，你可以交换若干个点对使得任意一个红点到达与其最近的黑点的距离小于等于m。

思路：
　　动态规划。
　　f[i][j][k]表示以i为根的子树中，连向结点j，子树中已经确定有k个是黑点所需要的最小交换次数。
　　best[i][k]表示以i为根的子树，已经确定有k个是黑点所需要的最小交换次数。
　　设当前根为x，子结点为y，连向结点i，总共确定了k个黑点，新确定了l个黑点，转移方程为：
　　f[x][i][k]=min(min{f[x][i][k-l]+best[y][l]},min{f[x][i][k-l+1]+f[y][i][l]-!col[i]});
　　当然要判断新连向的点与当前根的距离，这可以事先跑一遍O(n^3)的Floyd。
　　最后会被卡内存，据lyx介绍，由于n<=500，可以用uint16卡过去。

 #include<cstdio>
 #include<vector>
 typedef unsigned short uint16;
 inline int getint() {
     register char ch;
     while(!__builtin_isdigit(ch=getchar()));
     register int x=ch^'';
     while(__builtin_isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 template<typename _T1,typename _T2>
 inline _T1 min(const _T1 &a,const _T2 &b) {
     return a<b?a:b;
 }
 template<typename _T1,typename _T2>
 inline _T1 max(const _T1 &a,const _T2 &b) {
     return a>b?a:b;
 }
 const uint16 inf=~;
 const uint16 N=;
 bool col[N];
 uint16 n,s;
 int m;
 int dis[N][N];
 std::vector<uint16> e[N];
 inline void add_edge(const uint16 &u,const uint16 &v,const int &w) {
     e[u].push_back(v);
     e[v].push_back(u);
     dis[u][v]=dis[v][u]=w;
 }
 uint16 f[N][N][N],best[N][N],size[N];
 void dfs(const uint16 &x,const uint16 &par) {
     for(uint16 i=;i<e[x].size();i++) {
         const uint16 &y=e[x][i];
         if(y==par) continue;
         dfs(y,x);
     }
     for(register uint16 i=;i<=n;i++) {
         if(dis[x][i]>m) continue;
         size[x]=;
         f[x][i][]=!col[i];
         for(register uint16 j=;j<e[x].size();j++) {
             const uint16 &y=e[x][j];
             if(y==par) continue;
             for(register uint16 k=min(s,size[x]+size[y]);;k--) {
                 uint16 tmp=inf;
                 for(register uint16 j=max(k-size[x],);j<=min(k,size[y]);j++) {
                     tmp=min(tmp,f[x][i][k-j]+best[y][j]);
                 }
                 for(register uint16 j=max(k-size[x],)+;j<=min(k,size[y]);j++) {
                     tmp=min(tmp,f[x][i][k-j+]+f[y][i][j]-!col[i]);
                 }
                 f[x][i][k]=tmp;
                 if(!k) break;
             }
             size[x]+=size[y];
         }
     }
     for(register uint16 i=;i<=s;i++) {
         best[x][i]=inf;
         for(register uint16 j=;j<=n;j++) {
             best[x][i]=min(best[x][i],f[x][j][i]);
         }
     }
 }
 int main() {
     n=getint(),m=getint();
     for(register uint16 i=;i<=n;i++) {
         s+=(col[i]=getint());
     }
     __builtin_memset(dis,0x3f,sizeof dis);
     for(register uint16 i=;i<n;i++) {
         const uint16 u=getint(),v=getint();
         const int w=getint();
         add_edge(u,v,w);
     }
     for(register uint16 k=;k<=n;k++) {
         for(register uint16 i=;i<=n;i++) {
             for(register uint16 j=;j<=n;j++) {
                 dis[i][j]=i==j?:min(dis[i][j],dis[i][k]+dis[k][j]);
             }
         }
     }
     __builtin_memset(f,0xff,sizeof f);
     __builtin_memset(best,0xff,sizeof best);
     dfs(,);
     __builtin_printf("%d\n",best[][s]==inf?-:best[][s]);
     return ;
 }