DAG模型——嵌套矩阵

　　有向无环图上的动态规划是学习动态规划的基础，很多问题都可以转化为DAG上的最长路、最短路或路径计数问题。

嵌套矩阵

　　有n个矩阵，每个矩阵可以用两个整数a,b描述，表示它的长和宽。矩阵X(a,b)可以嵌套在矩阵Y(c,d)中当且仅当a<c,b<d，或者b<c,a<d（相当于把矩阵X旋转90^。）例如(1,5)可以嵌套在(6,2)内，但不能嵌套在(3,4)内。你的任务是选出尽量多的矩阵排成一行，使得除了最后一个只之外，每一个矩形都可以嵌套在下一个矩形内。

分析：

　　矩阵之间的“可嵌套”关系是一个典型的二元关系，二元关系可以用图来建模。如果矩形X可以嵌套在矩形Y里，我们就从X到Y连一条有向边，这个图是无环的，因为一个矩形无法直接或者间接地嵌套在自己内部。换句话说，它是一个DAG，我们的任务便是求DAG上的最长路径。

　　设d(i)表示从结点i 出发的最长路长度。第一步只能到它的相邻点，d(i) = max{d(j)+1|(i,j)属于E}，其中E是边集。最终答案是所有d(i)中的最大值。假设用邻接矩阵保存在矩阵G中。

记忆化搜索代码如下：

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #define maxn 1000
 using namespace std;
 int G[maxn][maxn], a[maxn], b[maxn], d[maxn], n, answer;
 int dp(int i)
 {
     int& ans = d[i];
     if (ans > ) return ans;
     ans = ;
     for(int j = ; j <= n; ++j) if(G[i][j]) ans = max(ans, dp(j)+);
     return ans;
 }
 void print_ans(int i)
 {
     printf("%d(%d, %d) ", i, a[i], b[i]);
     for(int j = ; j <= n; ++j) if(G[i][j] && d[j]+ == d[i])
         {
             print_ans(j);
             break;
         }
 }

 int path[maxn] = {}, cnt = ;
 void print_all(int i)
 {
     //输出所有符合条件的路径
     path[++cnt] = i;
     if(cnt == answer)
     {
         for(int j = ; j <= cnt; ++j) printf("%d(%d, %d) ", path[j], a[path[j]], b[path[j]]);
         printf("\n");
     }
     else for(int j = ; j <= n; ++j) if(G[i][j] && d[j]+ == d[i])
             {
                 print_all(j);
             }
     --cnt;
 }
 /*
 //作者的方法
 int path[maxn];
 void print_all(int cur, int i) {
   path[cur] = i;
   if(d[i] == 1) {
     for(int j = 0; j <= cur; j++) printf("%d ", path[j]);
     printf("\n");
   }
   for(int j = 1; j <= n; j++) if(G[i][j] && d[i] == d[j]+1)
     print_all(cur+1, j);
 }
 */
 int main()
 {
     freopen("9-2.in", "r", stdin);
     scanf("%d", &n);
     for(int i = ; i <= n; ++i) scanf("%d%d", a+i, b+i);
     memset(G, , sizeof(G));
     for(int i = ; i <= n; ++i)
         for(int j = ; j <= n; ++j) if((a[i]>a[j]&&b[i]>b[j])||(a[i]>b[j]&&b[i]>a[j]))
                 G[i][j] = ;
     int t, s;
     answer = -;
     memset(d, , sizeof(d));
     for (int i = ; i <= n; ++i)
     {
         t = dp(i);
         if(answer < t)
         {
             answer = t;
             s = i;
         }
     }
     printf("%d\n", answer);
     print_ans(s);
     printf("\nAll routes:\n");
     //print_all(0, s);
     print_all(s);
     return ;
 }

另一代码如下：

 //另附0ms     236kb的DP思路：按边长降序排序，用类似LIS的方法求解，只是比较元素大小的方法变成了比较长和宽
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #define maxn 1008
 using namespace std;
 int G[maxn][maxn], a[maxn], b[maxn], d[maxn], n;
 int dp(int i)
 {
     int& ans = d[i];
     if (ans > ) return ans;
     ans = ;
     for(int j = ; j <= n; ++j) if(G[i][j]) ans = max(ans, dp(j)+);
     return ans;
 }
 int main()
 {
     int t;
     scanf("%d", &t);
     while(t--)
     {
         scanf("%d", &n);
         for(int i = ; i <= n; ++i) scanf("%d%d", a+i, b+i);
         memset(G, , sizeof(G));
         for(int i = ; i <= n; ++i)
             for(int j = ; j <= n; ++j) if((a[i]>a[j]&&b[i]>b[j])||(a[i]>b[j]&&b[i]>a[j]))
                     G[i][j] = ;
         int ans = -, t, s;
         memset(d, , sizeof(d));
         for (int i = ; i <= n; ++i)
         {
             t = dp(i);
             if(ans < t)
             {
                 ans = t;
                 s = i;
             }
         }
         printf("%d\n", ans);
     }
     return ;
 }