动态规划

1.给你一个数字矩阵，从左上角开始，每次只能向下或向右，走到右下角。选到的和最大是多少？

  1   3   2  99   5   6

  3   6   9    8   7   4

  1   1   3    6   6   8

#include<bits/stdc++.h>
using namespace std;

int a[1005][1005];
int dp[1005][1005];
int N,M;

int num()
{
    for(int i=1;i<=N;i++)
        for(int j=1;j<=M;j++)
    {
        if(i==1&&j==1) dp[i][j]=a[1][1];
        dp[i][j]=max(dp[i-1][j],dp[i][j-1])+a[i][j];
    }
    return dp[N][M];
}

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>N>>M;
        for(int i=1;i<=N;i++)
            for(int j=1;j<=M;j++)
            cin>>a[i][j];
        cout<<num()<<endl;
    }
    return 0;
}

2.给你一个长度为N(N <= 1e5)的序列a[1]~a[N]（a[i] <= 1e9），让你找出最长非递减子序列的长度（可以不用连续）< LIS >

（即最长递增序列）

int Find(int l,int r,int x)
{
    while(l <= r)
    {
        int mid = (l + r)>>1;
        if(x >= d[mid])
        {
            l = mid + 1;
        }
        else
        {
            r = mid - 1;
        }
    }
    return l;
}
int LIS()
{
    d[1] = a[1];
    int len = 1;
    for(int i = 2; i <= n; i++)
    {
        int loc;
        if(a[i] >= d[len])
        {
             len++;
             d[len] = a[i];
        }
        else
        {
            loc = Find(1,len,a[i]);
            d[loc] = a[i];
        }
 
    }
    return len;
}

3.给你两个长度为N（N <= 1000）的序列A, B让你求A,B最长公共子序列（不需要连续）< LCS >   (最长公共子序列）

if(A[i]==B[j])
	 dp[i][j] = dp[i-1][j-1]+1;
 else
	 dp[i][j] = max(dp[i-1][j], dp[i][j-1]);

4.树形dp

给你一棵节点个数为N(N <= 1e5)并且以节点1为根的树。让你求出每个节点为根对应的子树的节点个数的数量

void dfs(int root)//计算dp[root]
{
    dp[root] = 1;
    visit[root] = true;
    for(int i = head[root]; i != -1; i = Edge[i].last)
    {
        int v = Edge[i].to;
        if(!visit[v])
        {
            dfs(v);
            dp[root] += dp[v];
        }
    }
}

部分动态规划可借助树状数组做优化