矩形嵌套 DAG

DAG上的动态规划。
排完序后，其实就是求最长递增子序列吧。这里要注意的是，我们排序的时候，以为它说可以翻转，所以我们把哪个边长短的放在前面，长的放在后面，再排序。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1005;
struct node
{
    int c,k;
}a[maxn];
bool cmp(node a1,node a2)
{
    if(a1.c!=a2.c) return a1.c<a2.c;
    else return a1.k<a2.k;
}
int dp[maxn];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        memset(a,0,sizeof(a));
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++){
            scanf("%d %d",&a[i].c,&a[i].k);
            if(a[i].c>a[i].k) swap(a[i].c,a[i].k);
        }
        sort(a,a+n,cmp);
        int ans=0;
        for(int i=0;i<n;i++)
        {
            dp[i]=1;
            for(int j=i;j>=0;j--)
            {
                if(a[i].k>a[j].k&&a[i].c>a[j].c) dp[i]=max(dp[i],dp[j]+1);
            }
            ans=max(dp[i],ans);
        }
        printf("%d\n",ans);
    }
    return 0;
}

然后我们用建图，然后记忆化搜索

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1005;
struct node
{
    int c,k;
}a[maxn];
int M[maxn][maxn];
int dp[maxn];
int ans=0,temp=0;
int n;
int dfs(int now)
{
    if(dp[now]) return dp[now];
    dp[now]=1;
    for(int i=0;i<n;i++)
    {
        if(M[now][i])
        {
            dp[now]=max(dfs(i)+1,dp[now]);
        }
    }
    return dp[now];
}/*
int dfs(int i){
    int &ans=dp[i];
    if(ans>0) return ans;
    ans=1;
    for(int j=1;j<=n;j++)
        if(M[i][j])
                ans=max(dfs(j)+1,ans);
    return ans;
}*/

void print_ans(int i)//输出路径
{
    printf("%d ",i);
    for(int j=0;j<n;j++)
        if(G[i][j]&&dp[i]=dp[j]+1) {printf_ans(j);
    break;
        }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,0,sizeof(dp));
        memset(M,0,sizeof(M));
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d %d",&a[i].c,&a[i].k);
            if(a[i].c>a[i].k) swap(a[i].c,a[i].k);
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(a[j].c>a[i].c&&a[j].k>a[i].k) M[i][j]=1;
            }
        }
        int maxx=0;
        for(int i=0;i<n;i++)
        {
            dfs(i);
            if(dp[i]>maxx) maxx=dp[i];
        }
        printf("%d\n",maxx);
    }
    return 0;
}