UVA 103 Stacking Boxes（DAG 上的最长路及其字典序输出）

题目大意：给定k个n维的盒子，求最多可以嵌套多少个盒子，类似于二维的盒子嵌套，对于n维的盒子稍作处理即可，首先将k个盒子看做k个点，建图，如果n维盒子X可以嵌套在n维盒子Y中，那么我们就从X到Y连一条有向边，对建好的图做记忆化搜索即可，输出时注意字典序输出。

#include <cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 1000+10
int max(int a, int b)
{
    return a>b?a:b;
}

int G[maxn][maxn],a[maxn][maxn]; 		//DAG图的矩阵表示
int d[maxn],n,m;			//d[i]顶点i的最长路径

//构造图
void createGraph()
{
    memset(G,0,sizeof(G));
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
        {
            int f=1;
            for(int k=0; k<m; k++)
                if(a[i][k]<=a[j][k])
                {
                    f=0;
                    break;
                }
            if(f)
                G[i][j]=1;
        }

}
//记忆化搜索程序
int dp(int i)
{
    int& ans=d[i];	//为该表项声明一个引用，简化对它的读写操作。
    if(ans>0)
        return ans;
    ans=1;
    for(int j=0; j<n; j++)
    {
        if(G[i][j])
            ans = max(ans, dp(j) + 1);
    }
    return ans;
}
void print_ans(int i)///递归到最小的，回溯时输出
{
    for(int j=0; j<n; j++)
    {
        if(G[i][j]&&d[i]==d[j]+1)
        {
            print_ans(j);
            break;
        }
    }
printf("%d ",i+1);
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        int ans=0;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)

                scanf("%d",&a[i][j]);
            sort(a[i],a[i]+m);
        }
        createGraph();

        //初始化记忆数组
        memset(d,0,sizeof(d));
        int t;
        for(int i=0; i<n; i++)
        {
            int tmp=dp(i);
           if(tmp>ans)
           {
               ans=tmp;
               t=i;
           }
        }
            printf("%d\n",ans);
            print_ans(t);
            printf("\n");
    }
    return 0;
}