uva103(最长递增序列，dag上的最长路）

题目的意思是给定k个盒子，每个盒子的维度有n dimension

问最多有多少个盒子能够依次嵌套

但是这个嵌套的规则有点特殊，两个盒子，D = （d1,d2,...dn) ,E = (e1,e2...en) 只要盒子D的任意全排列，小于盒子E，那么就说明

盒子D能放入盒子E中，其实就是将两个盒子的维度排序，如果前一个盒子的维度依次小于后一个盒子，那么就说明前一个盒子能放入后一个盒子中

这个题目能够转化为最长递增子序列。

首先将盒子的维度从小到大排序，然后将k个盒子，按照排序后的第一维度从小到大排序

这样中的目的是，后面的盒子一定放不到前面的盒子里面，这样是为了消除无后效性。

如果不排序，那么将有后效性，比如第一个盒子不选，但是第二个盒子可以放到第一个盒子里面。

然后就转化为最长递增序列的问题了。

 /*
 感觉像是变形的最长递增子序列
 如何快捷的判断一个盒子进过变换能放到另一个盒子里面呢？
 */
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 using namespace std;
 const int INF = <<;
 struct node
 {
     int minNum;
     int id;
     int dimension[];
     bool operator<(const node&rhs)const
     {
         return minNum < rhs.minNum;
     }
 }a[];
 bool canInput[][];//canInput[i][j]判断j能不能放到i里面去
 int dp[];
 int path[];
 int ans[];
 int main()
 {
 
     int n,k,i,j,z;
     while(scanf("%d%d",&k,&n)!=EOF)
     {
         memset(ans,,sizeof(ans));
         memset(canInput,false,sizeof(canInput));
         memset(dp,,sizeof(dp));
         for(i=; i<k; ++i)
         {
             dp[i] = ;
             path[i] = i;
             a[i].minNum = INF;
             a[i].id = i+;
             for(j=; j<n; ++j)
             {
                 scanf("%d",&a[i].dimension[j]);
                 a[i].minNum = min(a[i].minNum,a[i].dimension[j]);
             }
             sort(a[i].dimension,a[i].dimension+n);
         }    
 
         sort(a,a+k);
         for(i=; i<k; ++i)//预处理，判断i能不能放到j里面去
             for(j=i+; j<k; ++j)
             {
                 bool can = true;
                 for(z=; z<n; ++z)
                 {
                     if(a[i].dimension[z] >= a[j].dimension[z])
                         can = false;
                 }
                 if(can)
                     canInput[j][i] = true;
             }
         //这里就是求最长递增子序列，时间复杂度是O(k*k)
         for(i=; i<k; ++i)
             for(j=; j<i; ++j)
             {
                 if(canInput[i][j])//预处理之后，就变成了一维的最长递增子序列的求解了
                 {
                     if(dp[j]+ >dp[i])
                     {
                         dp[i] = dp[j]+;
                         path[i] = j;
                         //break; 这里可不能break， 比如例子：1 2 3 4 5 11 12 13 10 14
                     }
                 }
             }
         int cnt = ,index;
         for(i=; i<k; ++i)
             if(cnt < dp[i])
             {
                 cnt = dp[i];
                 index = i;
             }
 
         printf("%d\n",cnt);
         ans[--cnt] = a[index].id;
 
         while(path[index]!=index)
         {
             ans[--cnt] = a[path[index]].id;
             index = path[index];
         }
         printf("%d",ans[cnt++]);
         while(ans[cnt]!=)
         {
             printf(" %d",ans[cnt++]);
         }
         puts("");
     }
     return ;
 }

当然也可以建图（dag图），然后求最长路， 最长路的一种求法就是进行拓扑排序，然后进行最长递增子序列dp，  拓扑排序同上面的排序一样，也是为了消除后效性

然后这种做法，相当于上面，太复杂了。 但是是为了天马行空的想法而A题，而不是为了A题而A题。

 /*
 建图（dag图），
 拓扑排序
 dp
 */
 
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <stack>
 using namespace std;
 const int INF = <<;
 struct node
 {
     int dimension[];
 
 }a[];
 bool canInput[][];//canInput[i][j]判断i能不能放到j里面去
 int dp[];
 int path[];
 int ans[];
 int in[];
 int sequeue[];
 int main()
 {
     int n,k,i,j,z;
     while(scanf("%d%d",&k,&n)!=EOF)
     {
         memset(ans,,sizeof(ans));
         memset(canInput,false,sizeof(canInput));
         memset(dp,,sizeof(dp));
         memset(in,,sizeof(in));
         for(i=; i<k; ++i)
         {
             dp[i] = ;
             path[i] = i;
             for(j=; j<n; ++j)
             {
                 scanf("%d",&a[i].dimension[j]);
             }
             sort(a[i].dimension,a[i].dimension+n);
         }    
 
         for(i=; i<k; ++i)//预处理，建图
             for(j=i+; j<k; ++j)
             {
                 bool can = true;
                 for(z=; z<n; ++z)
                 {
                     if(a[i].dimension[z] >= a[j].dimension[z])
                         can = false;
                 }
                 if(can)
                     canInput[i][j] = true;
                 can = true;
                 for(z=; z<n; ++z)
                 {
                     if(a[i].dimension[z] <= a[j].dimension[z])
                         can = false;
                 }
                 if(can)
                     canInput[j][i] = true;
 
             }
         //每个结点的入度
         for(i=; i<k; ++i)
         {
             for(j=; j<k; ++j)
                 if(canInput[i][j])
                     in[j]++;
         }
         //拓扑排序，sequeue数组存在排序之后的序列
         for(i=; i<k; ++i)
         {
             for(j=; in[j]&&j<k; ++j)
                 NULL;
             in[j] = -;
             sequeue[i] = j;
             for(z=; z<k; ++z)
                 if(canInput[j][z])
                     in[z]--;
         }
 
         //对拓扑排序之后的序列进行最长递增子序列的dp
         for(i=; i<k; ++i)
             for(j=; j<i; ++j)
             {
                 if(canInput[sequeue[j]][sequeue[i]] && dp[j]+>dp[i])//sequeue[i]
                 {
                     dp[i] = dp[j]+;
                     path[i] = j;
                 }
             }
         int cnt = ,index;
         for(i=; i<k; ++i)
             if(cnt < dp[i])
             {
                 cnt = dp[i];
                 index = i;
             }
         printf("%d\n",cnt);
 
         ans[--cnt] = index;
         while(path[index] != index)
         {
             ans[--cnt] = path[index];
             index = path[index];
         }
         //sequeue[i]
         printf("%d",sequeue[ans[cnt++]]+);
         while(ans[cnt]!=)
         {
             printf(" %d",sequeue[ans[cnt++]]+);
         }
         puts("");
     }
     return ;
 }