【uva1380 - 一个调度问题】思路题+树形dp

【题意】 有n<=200个恰好需要一天完成的任务，要求用最少的时间完成所有任务。任务可以同时完成。但是有一些约束，分有向和无向两种，其中A-->B表示A必须在B前面完成，而A--B表示A和B不能在同一天完成。

题解：最具体的题解在紫书上。。。

如果树上的所有边都是有向边，那么答案就是最长链上的点数。

这个显然。。因为A-->B--->C---->D就最少需要四天。。

这样，原问题转化为：将树上所有的无向边定向，使得树上的最长链最短。

最长链最短——二分答案。

现在问题再次转化：给定一个x，判断是否可以给无向边定向，使得最长链的点数<=x。

设定f[i]表示以i为根的子树全部定向后，最长链点数不超过x的前提下，后代到i的最长链的最小值。g[i]相反（i到后代）。

设y为i的某个孩子。

转化无向边的过程分为两种情况：

a. 如果一个子树中不存在无向边，则经过子树的根结点的最长有向路结点数为f+g+1。

b. 如果一个结点a的子结点存在无向边，则我们先递归求出所有a的子结点的f和g，然后暴力枚举将所有无向边转化为上行/下行有向边，对于每一种枚举，按照上面不存在无向边时的方法，求出f,  g和f+g+1，检查是否大于k。枚举的过程中，记下所有成功的枚举中最小的f和g，把它们和原本就是有向边子结点的最小的f和g比较，取较大值。（f和g本身是最长路的长度，这里要取的是不同成功的枚举情况下，遇到的最小的f和g。）

如何给边定向呢？

但是如果我们完全枚举无向边的转换方法，则复杂度为O(2^n)，n为子结点中无向边的数量。这里有一个非常棒的优化：

求出所有子结点的f和g之后，把无向边的f和g值存到一个数组中，按照f值排序。

之后我们从第一位开始考虑，将无向边换为下行有向边，考虑到第p位的时候，我们可以将前p-1位的无向边一并换为下行有向边。因为第p位的f值大于前p-1位无向边的f值，将前p-1位同时换为下行有向边，整个树的f值不会变（f为最长路的长度，而排序后，前p-1位形成的路都不会比第p位长），而g值有可能变小。这时，我们找出第p+1位到第n位中最大的g值，求出f+g+1，检查是否小于等于k即可。一旦有某一个p满足了要求就可以得出结果并终止枚举。复杂度为线性。

也就是说，我们只需要枚举p，把f值前小的全部定向为y-->i。

求g的过程相同，按照g值排序、枚举即可。

为什么取的是不同情况下遇到的最小的f和g呢？

因为对于以后要用到f[i]和g[i]的点，必定是i的父亲，它每次只用到f[i]或g[i]。

但是对于根节点而言，它的最长链是f[i]+g[i]，这里的f[i]和g[i]取了不同的情况，所以我们在求f[i]、g[i]的时候就看ff+gg+1是否<=lim，是的话才更新。也就是说，如果没有一种方案满足，f[i]和g[i]都是INF。

所以最后判断是否可行只需要看根节点的f[i]或g[i]是否<INF即可。

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;

 const int N=,INF=(int)1e9;
 int n,len,tl,f[N],g[N],first[N];
 struct node{
     int x,y,next,tmp;
     bool bk;
 }a[N];
 struct point{
     int d,id;
 }tf[N],tg[N];

 int maxx(int x,int y){return x>y ? x:y;}
 int minn(int x,int y){return x<y ? x:y;}

 void ins(int x,int y,int tmp)
 {
     a[++len].x=x;a[len].y=y;a[len].tmp=tmp;a[len].bk=;
     a[len].next=first[x];first[x]=len;
 }

 bool cmp(point x,point y){return x.d<y.d;}

 void dp(int x,int lim)
 {
     for(int i=first[x];i;i=a[i].next) dp(a[i].y,lim);
     tl=;
     for(int i=first[x];i;i=a[i].next)
     {
         int y=a[i].y;
         if(a[i].tmp==)
         {
             tl++;
             tf[tl].d=f[y];tf[tl].id=i;
             tg[tl].d=g[y];tg[tl].id=i;
         }
     }
     sort(tf+,tf++tl,cmp);
     sort(tg+,tg++tl,cmp);
     if(tl==)
     {
         f[x]=;g[x]=;
         for(int i=first[x];i;i=a[i].next)
         {
             int y=a[i].y;
             if(a[i].tmp==) f[x]=maxx(f[x],f[y]+);
             if(a[i].tmp==) g[x]=maxx(g[x],g[y]+);
             if(f[x]+g[x]+>lim) {f[x]=INF,g[x]=INF;break;}
         }
         if(!first[x]) f[x]=g[x]=INF;//debug
     }
     else
     {
         //find_f
         f[x]=INF;g[x]=INF;
         int ff,gg;
         for(int k=;k<=tl;k++)
         {
             ff=;gg=;
             if(k>) a[tf[k].id].bk=;
             for(int i=first[x];i;i=a[i].next)
             {
                 int y=a[i].y;
                 if(a[i].tmp== || (a[i].tmp== && a[i].bk==)) ff=maxx(ff,f[y]+);
                 if(a[i].tmp== || (a[i].tmp== && a[i].bk==)) gg=maxx(gg,g[y]+);
             }
             if(ff+gg+<=lim) f[x]=minn(f[x],ff);
         }
         for(int k=;k<=tl;k++) a[tf[k].id].bk=;

         for(int k=;k<=tl;k++)
         {
             ff=;gg=;
             if(k>) a[tg[k].id].bk=;
             for(int i=first[x];i;i=a[i].next)
             {
                 int y=a[i].y;
                 if(a[i].tmp== || (a[i].tmp== && a[i].bk==)) ff=maxx(ff,f[y]+);
                 if(a[i].tmp== || (a[i].tmp== && a[i].bk==)) gg=maxx(gg,g[y]+);
             }
             if(ff+gg+<=lim) g[x]=minn(g[x],gg);
         }
         for(int k=;k<=tl;k++) a[tg[k].id].bk=;
     }
     // printf("f %d = %d   g %d = %d\n",x,f[x],x,g[x]);
 }

 bool check(int lim)
 {
     // printf("lim = %d\n",lim);
     dp(,lim);
     return (f[]<INF);
 }

 int main()
 {
     freopen("a.in","r",stdin);
     int n,y;
     char ch;
     while()
     {
         n=;
         len=;
         memset(first,,sizeof(first));
         while()
         {
             int x;
             scanf("%d",&x);
             if(x==) break;
             n=maxx(n,x);
             while()
             {
                 scanf("%d%c",&y,&ch);
                 n=maxx(n,y);
                 if(y==) break;
                 if(ch=='d') ins(x,y,);
                 else if(ch=='u') ins(x,y,);
                 else ins(x,y,);
             }
         }
         if(n==) break;
         int l=,r=n,mid;//debug 是n而不是n-1
         while(l<r)
         {
             mid=(l+r)/;
             if(check(mid)) r=mid;
             else l=mid+;
         }
         printf("%d\n",l);
     }
     return ;
 }