DAG模型

题目就不写了
a11
a21 a22
a31 a32 a33
a41 a42 a43 a44
求和 呜啊

递归版
int solve(int row,int line){
	return sz[row][line]+(row == n ? 0:max(solve(row+1,line),solve(row+1,line+1)));
递推要有一个固定的顺序 但是记忆化搜索的话就不需要有什么顺序 只要记住就可以了
时间复杂度好大
}

递推版
都会不写了

记忆化搜索 好像就是把搜索到的地方记起来然后方便后边的查找
int solve(int i,int j){
if(d[i][j] != -1) return d[i][j];
return d[i][j] = a[i][j] + (i == n ? 0:max(solve(i+1,j),solve(i+1,j+1)));
}

这类问题都可以转化成DAG模型
转换成求最大路径的问题 enummmmmmm 明天接着看 自己手撸了一个  看大佬的博客就是牛批 两种写法 牛批  交换函数秀了我一脸 要求求的是按最小的字典序输出 呜啊 又tm秀了我一脸  原来可以这样！！！
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void diction(int,int [],int n,int[][n]);
int max(int,int);
int fun(int,int n,int[][n],int[]);
void mark(int[][2],int n,int[][n]);
void input(int,int[][2]);
int main(void) 
{
	int n,i,j;
	scanf("%d",&n);
	int rect[n][2],map[n][n],dag[n],ans = 0;
	input(n,rect);
	memset(map,0,sizeof(map));memset(dag,0,sizeof(dag));//
	mark(rect,n,map);
	for(i = 0;i < n;i++)
	{
		ans = max(ans,fun(i,n,map,dag));
	}
	for(i = 0;i < n;i++)
	{
		if(ans == dag[i])
		{
			diction(i,dag,n,map);
			break;
		}
	} 
	return 0;
} 
void diction(int befo,int dag[],int n,int map[][n])
{
	printf("%d",befo+1);
	int i;
	for(i = 0;i < n;i++)
	{
		if(map[befo][i] && dag[i] == dag[befo]-1){
			diction(i,dag,n,map);
			break;
		}
	}
}
int max(int a,int b)
{
	return a > b ? a : b;
}
int fun(int dq,int n,int map[][n],int dag[])
{
	if(dag[dq] > 0)
	{
		return dag[dq];
	}
	int i;
	dag[dq] = 1;
	for(i = 0;i < n;i++)
	{
		if(map[dq][i])
		{
			dag[dq] = max(dag[dq],fun(i,n,map,dag)+1);
		}
	}
	return dag[dq];
}
void mark(int rect[][2],int n,int map[][n])
{
	int i,j;
	for(i = 0;i < n;i++)
	{
		for(j = 0;j < n;j++)
			if(rect[j][0] > rect[i][0] && rect[j][1] > rect[i][1]) map[i][j] = 1;
	}
}
void input(int n,int r[][2])
{
	int i,tmp;
	for(i = 0;i < n;i++)
	{
		scanf("%d%d",r[i],r[i]+1);
		if(r[i][0] > r[i][1]) 
		{
			tmp = r[i][0];r[i][0] = r[i][1];r[i][1] = tmp;//为了偷懒所以就这样写了 
		}
	}
}

/* DAG上的动态规划之嵌套矩形 */
#include <cstdio>
#include <cstring>

const int maxn = 1005;
int n, G[maxn][maxn];
int a[maxn], b[maxn];
int dp[maxn];

void swap(int &x, int &y){
    x ^= y;
    y ^= x;
    x ^= y;
}

//将x和y的最大值存在x中
inline void CMAX(int& x, int y){
    if (y > x){
        x = y;
    }
}

/* 采用记忆化搜索 求从s能到达的最长路径 */
int DP(int s){
    int& ans = dp[s];
    if (ans > 0)
        //记忆化搜索,避免重复计算
        return ans;
    ans = 1;
    for (int j = 1; j <= n; ++j){
        if (G[s][j]){
            //sj有边 利用子问题dp[j]+1更新最大值
            CMAX(ans, DP(j) + 1);
        }
    }
    return ans;
}

void print_ans(int i){
    printf("%d ", i);
    for (int j = 1; j <= n; ++j){
        if (G[i][j] && dp[j] + 1 == dp[i]){
            print_ans(j);
            break;
        }
    }//for(j)
}

int main()
{
#ifdef _LOCAL
    freopen("D:\\input.txt", "r", stdin);
#endif
    while (scanf("%d", &n) == 1){
        //n个矩形
        for (int i = 1; i <= n; ++i){
            //默认a存长,b存宽(a > b)
            scanf("%d%d", a + i, b + i);
            if (a[i] < b[i]){
                swap(a[i], b[i]);
            }
        }
        /*
            建图 G[i][j]为1表示矩形i可以嵌套在矩形j中
            那么原问题便转化为求DAG上的最长路径
            
            定义状态dp[i]表示从结点i出发可以到达的最长路径
            则 dp[i] = max(dp[j] + 1), 其中 G[i][j]=1，
        */
        memset(G, 0, sizeof G);
        for (int i = 1; i <= n; ++i){
            for (int j = 1; j <= n; ++j){
                //矩形i的长和宽都小于矩形j的长和宽
                if (a[i] < a[j] && b[i] < b[j]){
                    G[i][j] = 1; //可以嵌套,则有边
                }
            }
        }//for(i)
        memset(dp, 0, sizeof dp);
        int ans = 0;
        int best;
        for (int i = 1; i <= n; ++i){
            if (DP(i) > ans){
                ans = dp[i];
                best = i;
            }
        }//for(i)
        printf("ans = %d\n", ans);
        print_ans(best);
        printf("\n");
    }
    return 0;
}

还有求最大上升子序列 求大佬带飞
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1005;
int dp[maxn];

struct Node{
    int a, b;
    bool operator<(Node& other){
        if (a != other.a){
            return a < other.a;
        }
        else{
            return b < other.b;
        }
    }
}A[maxn];

void SWAP(int& x, int& y){
    x ^= y;
    y ^= x;
    x ^= y;
}

void CMAX(int& x, int y){
    if (y > x){
        x = y;
    }
}

int main()
{
#ifdef _LOCAL
    freopen("D:\\input.txt", "r", stdin);
#endif

    int n;
    while (scanf("%d", &n) == 1){
        for (int i = 1; i <= n; ++i){
            //a为长,b为宽
            scanf("%d%d", &A[i].a, &A[i].b);
            if (A[i].a < A[i].b){
                SWAP(A[i].a, A[i].b);
            }
            dp[i] = 1;
        }//for(i)
        sort(A + 1, A + n + 1);
        //求b的最长上升子序列
        int ans = 1;
        int best = 0;
        dp[0] = 0;
        for (int i = 1; i <= n; ++i){
            for (int j = 0; j < i; ++j){
                if (A[j].a < A[i].a && A[j].b < A[i].b){
                    CMAX(dp[i], dp[j] + 1);
                }
            }
            if (dp[i] > ans){
                ans = dp[i];
                best = i;
            }
            //CMAX(ans, dp[i]);
        }

        printf("ans = %d\n", ans);
    }


    return 0;
}