1516-嵌套矩形

题目描述

有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)内。你的任务是选出尽可能多的矩形排成一行。使得

除了最后一个之外，每个矩形都可以嵌套在下一个矩形内。

输入

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

随后的n行，每行有两个数a,b(0<a,b<100)，表示矩形的长和宽

输出

每组测试数据都输出一个数，表示最多符合条件的矩形数目，每组输出占一行

输入样例

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

输出样例

5

思路

两种方法可以解决这个问题，一种用动态规划的思想求该有向无环图的最长路径，最核心的就是状态方程dp(i)=max{dp(j)+1|graph[i][j]=1},另外一种就是用拓扑排序的方法（来自于·一个超级厉害的大神）记录入度为0的点，将入度为0的点保存在队列中，将入度为0的点删除，同时与该点连接的其它点入度数减一，循环下去。

代码

动态规划

#include <iostream>
#include<string.h>
using namespace std;
const int Max = 1e3+5;
int G[Max][Max];
int d[Max],n;
struct node
{
    int x,y;
} r[Max];
int isedge(node a,node b)
{
    if((a.x > b.x && a.y > b.y)||(a.x > b.y && a.y > b.x))
        return 1;
    else
        return 0;
}
int dp(int i)
{
    int& ans = d[i];
    if(d[i] > 0)  return ans;
    ans = 1;
    for(int j = 1; j <= n; ++j)
    {
        if(G[i][j])
            ans = max(ans,dp(j)+1);
    }
    return ans;
}
int main()
{
    while(cin>>n)
    {
        memset(G,0,sizeof(G));
        memset(d,0,sizeof(d));
        for(int i = 1; i <= n; ++i)
        {
            cin>>r[i].x>>r[i].y;
            for(int j = 1; j <= i; ++j)
            {
                if(i == j)
                 continue;
           if(isedge(r[j],r[i]))  G[j][i]=1;
           if(isedge(r[i],r[j]))  G[i][j]=1;
            }
        }
        int ans=0;
        for(int i = 1; i <= n; ++i)
        {
            ans = max(ans,dp(i));
        }
        cout<<ans<<endl;
    }
    return 0;
}

第二种：拓扑排序

#include <iostream>
#include<string.h>
#include<queue>
#include<cmath>
using namespace std;
const int Max = 1e3+5;
int G[Max][Max];
int dp[Max],n;
struct Node
{
    int x,y,in;
}r[Max];
int isedge(Node a,Node b)
{
    if((a.x > b.x && a.y > b.y)||(a.x > b.y && a.y > b.x))
       return 1;
    else
       return 0;
}
int topSort()
{
    int ans = 0;
    queue<int>q;
    for(int i = 1; i <= n; ++i)
    {
        if(r[i].in == 0)
            q.push(i);
    }
    while(!q.empty())
    {
        int k = q.front();
        q.pop();
        for(int i = 1; i <= n; ++i)
        {
            if(G[k][i])
            {
                r[i].in--;
                dp[i] = max(dp[i],dp[k]+1);
                ans = max(ans,dp[i]);
                if(r[i].in == 0)
                q.push(i);
             }
        }
    }
    return ans+1;
}

int main()
{
   while(cin>>n)
   {
    memset(G,0,sizeof(G));
    memset(dp,0,sizeof(dp));
   for(int i = 1; i <= n; ++i)
   {
       cin>>r[i].x>>r[i].y;
       for(int j = 1; j <= i; ++j)
       {
           if(i == j)
            continue;
           if(isedge(r[j],r[i]))
           {
               G[i][j] = 1; r[j].in += G[i][j];
           }
           if(isedge(r[i],r[j]))
           {
                G[j][i] = 1; r[i].in += G[j][i];
           }
       }
   }
   cout<<topSort()<<endl;
   }
   return 0;
}