DP经典题目
题意还是比较好懂就是矩形嵌套，不过这个矩阵是m维的，而且嵌套要严格大于。
输入n和m，表示有n个维数为m的超立方体。下面n行每行m个数字，是每个超立方体的信息，即每个维的大小
超立方体的信息可以调整，判断一个超立方体a能不能套住超立方体b是看调整之后能不能
好像（2，6）和（7，3），可以调整为（2,6），（3,7），那么显然（3,7）是能套住（2,6）的
另外能不能套住，还需要每一维都严格大于，好像（2,6），（2,7），由于2相等不能套住
其实就是DAG模型，若i能套住j，则g[i][j]=1，然后这个有向图显然是无环的，（要套住必须严格大于，不可能存在互相套住的情况）。相当于求这个DAG上的最长路，dp思想就是 dp[i]=max{ dp[j]+1 }; (i能套住j) ， 这个dp思想用记忆化搜索很容易实现，详细看代码
另外我们把套住这种关系看做一种大于关系（i能套住j则认为i大于j），那么对超立方体内部信息排序后，还要对所有的超立方排序，得到一个“递增”的序列，再对这个递增的序列求LIS，个人觉得这个方法没有求最长路来得简单和直接，所以代码就不写了
后来想了另一种dp思想，就是求出任意两点的最长路，即dp[i][j]表示i到j的最长路，然后找到最大的dp[i][j]就是整个图的最长路
dp过程仿照floyd写3个循环。如果i能套住k，k能套住j，那么dp[i][j]=max( dp[i][j] , dp[i][k]+dp[k][j])
这个dp思想其实很好理解，看起来也没什么问题，但是一直wa，几乎想放弃了，然后出了随机数据来测才找到bug
算是逻辑不够严谨，这和整个图的特殊情况也有关系，所以初始化要处理好
1.整个图可以是独立的，根本没有边，也就是说所有超立方体都不能互相嵌套，整个图的最长路是0，顶点个数是1
2.整个图的最长路为1，即只有两两嵌套的情况，那个顶点个数是2。
这个两个特殊情况都有一个共同点，就是整个dp过程都没办法去更新dp[i][j]，（因为都不可能找到一个k插进去）
所以更新最大值的语句不能放在 if(i,k && k,j)循环内部，而应该放在3个for里面，即有没有更新dp[i][j]都好，都要拿dp[i][j]更新max
具体看代码
记忆化搜索AC代码
#include <cstdio> #include <cstring> #include <algorithm> #define N 35 #define M 15 using namespace std; int dp[N],p[N],g[N][N]; int n,m; struct box { int a[M]; }b[N]; int ans,x; int can_nest(int i , int j) //判断i能不能套住j { for(int k=0; k<m; k++) if(b[i].a[k] <= b[j].a[k]) return 0; return 1; } void dfs(int i) //记忆化搜索 { if(dp[i]!=-1) return ; dp[i]=1; for(int j=1; j<=n; j++) if(g[i][j]) { dfs(j); if(dp[j]+1>dp[i]) { dp[i]=dp[j]+1; p[i]=j; } } if(dp[i]>ans) { ans=dp[i]; x=i; } return ; } int main() { while(scanf("%d%d",&n,&m)!=EOF) { for(int i=1; i<=n; i++) for(int j=0; j<m; j++) scanf("%d",&b[i].a[j]); //对单个超立方体内部的信息排序，超立方体之间不同排序都行 for(int i=1; i<=n; i++) sort(b[i].a , b[i].a+m); memset(g,0,sizeof(g)); memset(dp,-1,sizeof(dp)); memset(p,-1,sizeof(p)); for(int i=1; i<=n; i++) //建立超立方体间的嵌套关系 for(int j=1; j<=n; j++) if(can_nest(i,j)) g[i][j]=1; ans=-1; x=0; for(int i=1; i<=n; i++) //记忆化搜索 if(dp[i]==-1) dfs(i); printf("%d\n",ans); int s[N],top; memset(s,0,sizeof(s)); top=-1; while(x!=-1) //用栈来迭代打印路径，递归打印也是可以的 { s[++top]=x; x=p[x]; } for(int i=top; i>=0; i--) //注意路径中最后一个数字不能有空格 if(i>0) printf("%d ",s[i]); else printf("%d",s[i]); printf("\n"); } return 0; }
在DAG上仿照floyd的dp，我找遍了所有的解题报告，没有人用这个方法的，算是原创吧……
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 35
#define M 15
struct box
{
int a[M];
}b[N];
int n,m;
int dp[N][N],p[N][N];
int can_nest(int i , int j) //i盒子能套住j盒子
{
for(int k=0; k<m; k++)
if(b[i].a[k] <= b[j].a[k])
return 0;
return 1;
}
void DP()
{
memset(dp,0,sizeof(dp));
memset(p,0,sizeof(p));
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
{
p[i][j]=j;
if(can_nest(i,j))
dp[i][j]=1;
}
int max=0,x=1,y=1;
//初始化可以应对所有点都是孤立的情况，也就是所有超立方体都不互相嵌套
for(int k=1; k<=n; k++)
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
{
if(can_nest(i,k) && can_nest(k,j))
{
if(dp[i][k]+dp[k][j] > dp[i][j])
{
dp[i][j]=dp[i][k]+dp[k][j];
p[i][j]=p[i][k];
}
}
//这个更新最大值不能放在
//if(can_nest(i,k) && can_nest(k,j))内部
//因为可能整个图没有办法找到一个k去更新ij
//也就是整个图的最长路是1或0，只有两个点或孤立，即一个矩形套住另一个或不能互相嵌套
if(dp[i][j]>max)
{ max=dp[i][j]; x=i; y=j;}
}
max++; //最长路+1才是顶点个数
printf("%d\n",max);
//用栈储存路径，当然也可以递归打印
int stack[N],top;
top=0;
stack[top]=x;
while(x!=y)
{
x=p[x][y];
stack[++top]=x;
}
while(top>=0)
{
if(top) printf("%d ",stack[top]);
else printf("%d",stack[top]);
top--;
}
printf("\n");
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
for(int i=1; i<=n; i++)
for(int j=0; j<m; j++)
scanf("%d",&b[i].a[j]);
for(int i=1; i<=n; i++)
sort(b[i].a , b[i].a+m);
DP();
}
return 0;
}