NYOJ16-矩形嵌套（DAG图动态规划）

矩形嵌套

时间限制：3000 ms | 内存限制：65535 KB

难度：4

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

输入 第一行是一个正正数N(0<N<10)，表示测试数据组数，

每组测试数据的第一行是一个正正数n，表示该组测试数据中含有矩形的个数(n<=1000)

随后的n行，每行有两个数a,b(0<a,b<100)，表示矩形的长和宽 输出 每组测试数据都输出一个数，表示最多符合条件的矩形数目，每组输出占一行 样例输入

1
10
1 2
2 4
5 8
6 10
7 9
3 1
5 8
12 10
9 7
2 2

样例输出

5

题意：给出一些矩形，大小不一，一个矩形只能套在完全大于自己的大矩形里面，问你最多能套多少层！

分析：看了刘汝佳的讲解，思路是这样的。如果我们将每个矩形看做是图上面的一个点，那么矩形A可以套住矩形B看做是图上的由A指向B的一条边，那么我们就可以将这个题目转化为求DAG（有向无环图）上的最长路了，这就是DAG上的动态规划，转移方程是d(i)=max{ d(j) + 1 | (i,j) 属于 E }。看下面代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define N 1010
struct node{
int xlen;
int ylen;
}set
;
int map

,d
,n;

int cmp(const void *a, const void *b) {//将矩形从大到小排序
int x1,y1,x2,y2;
x1=(*(struct node *)a).xlen;
y1=(*(struct node *)a).ylen;
x2=(*(struct node *)b).xlen;
y2=(*(struct node *)b).ylen;
if(x1!=x2)
return x2-x1;
else
return y2-y1;
}

int dp(int i) {
int j;
if(d[i]>0)
return d[i];
d[i]=1;
for(j=0;j<n;j++)
if(map[i][j] && d[i]<dp(j)+1)
d[i]=dp(j)+1;
return d[i];
}
/*
void print_ans(int i){
int j=0;
printf("%d %d\n",set[i].xlen,set[i].ylen);
for(j=0;j<n;j++)
if(map[i][j]&&d[i]==d[j]+1){
print_ans(j);
break;
}
}
*/
int main() {
int T,i,j,temp,ans;
scanf("%d",&T);
while(T--) {
scanf("%d",&n);
for(i=0;i<n;i++) {
scanf("%d %d",&set[i].xlen,&set[i].ylen);
if(set[i].xlen<set[i].ylen){
temp=set[i].xlen;
set[i].xlen=set[i].ylen;
set[i].ylen=temp;
}
}
qsort(set,n,sizeof(set[0]),cmp);
memset(map,0,sizeof(map));
for(i=1;i<n;i++){
for(j=0;j<i;j++){
if(set[j].xlen>set[i].xlen&&set[j].ylen>set[i].ylen)
map[j][i]=1;
}
}
memset(d,0,sizeof(d));
for(i=0,ans=0;i<n;i++){
temp=dp(i);
if(ans<temp)
ans=temp;
}
printf("%d\n",ans);
//print_ans(0);
}
//system("pause");
return 0;
}

说明：其中print_ans()方法用来按照字典序打印路径的，但是这里用不到。还有就是我对于这些矩形进行了排序，其实也可以不排序，但是这样建图的时候要多循环一些次数，有利也有弊嘛~。