动态规划

动态规划
数组
方程
以最长子序列为例

for(int i=2;i<=n;++i){
		dp[i]=0;
		for(int j=i-1;j>0;--j){
			if(a[i]>a[j]){
				dp[i]=max1(dp[i],dp[j]);
			}
		}
		dp[i]++;
		if(dp[i]>ans) ans=dp[i];
	}

初始化
P1216
从下向上，从倒数第二行开始，更新自己为可选择中较大的+自己

#include<iostream>
#include<math.h>
using namespace std;
int a[1001][1001] ;
int main()
{
	int m;
	cin>>m;
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	for(int i=m-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			a[i][j]=max(a[i+1][j],a[i+1][j+1])+a[i][j];
		}
	}
	cout<<a[1][1];
}

P2196

#include<iostream>
using namespace std;
int mp[1001][1001], f[1001], a[1338], p[1244], maxn = 0, maxi = 0, m;
void digui(int i)
{
	if (!i)
	{
		return;
	}

	digui(p[i]);
	cout << i << " ";
}
int main()
{

	cin >> m;
	for (int i = 1; i <= m; i++)
	{
		cin >> a[i];
		f[i] = a[i];
	}
	for (int i = 1; i < m; i++)
	{
		for (int j = i + 1; j <= m; j++)
		{
			cin >> mp[i][j];
		}
	}
	for (int i = 1; i <= m; i++)//遍历每一个
	{
		for (int j = 1; j < i; j++)
		{
			if (mp[j][i])/这里是j，i 
			{
				if (f[i] < f[j] + a[i])
				{
					f[i] = f[j] + a[i];
					p[i] = j;/记住路径，来到i的是j 
				}
			}
		}
		if (maxn < f[i])
		{
			maxn = f[i];
			maxi = i;
		}
	}
	digui(maxi);
	cout << endl << maxn;
}

对于dpi,用j把1到i-1枚举
如果从j到i有路可走且dpj>dpi 就更新
枚举完再加上自己的
找出比自己小的j使得dpj最大并且i,j之间有通路，再加上这一点的雷

P4017
拓扑排序，记录好入读出度，每一次更新到自己连接的，就是本身已经有的+这个通路过来的，因为求的是总和所以是加
然后如果这个家伙出入都为零，就是结束了
遍历全部把入度为零的入队再次

#include<iostream>
using namespace std;
int r[5005];
int mp[5005][5005],nb[5005],sb[5005],m,n,ans=0;
int dfs(int p)
{
	if(!nb[p])
	{
		return 1;
	 } 
	 if(r[p]) return r[p];
	 int sum=0;
	for(int i=1;i<=m;i++)
	{
		if(mp[i][p])
		{
			sum=(sum+dfs(i))%80112002;
		}
	}
	return r[p]= sum;
}
int main()
{
	
	cin>>m>>n;
	for(int i=1;i<=n;i++)
	{
		int x,y;
		cin>>x>>y;
		mp[x][y]=1;
		sb[x]++;
		nb[y]++;
	}
	for(int i=1;i<=m;i++)
	{
		if(sb[i]==0)
		ans=(ans+dfs(i))%80112002;
	}
	cout<<ans;
	return 0;
 } 

P1048
经典的01背包，两重循环，一重代表个数一重代表价值，然后第二重要反着来的，最大的是已有的或者加上新的

#include<iostream>
#include<cmath>
using namespace std;
int dp[10001];
int main()
{
	int T,M,t,m;
	cin>>T>>M;
	for(int i=1;i<=M;i++)
	{
		cin>>t>>m;
		for(int j=T;j>=t;j--)
		{
			dp[j]=max(dp[j],dp[j-t]+m) ;
		}
		
	}
	cout<<dp[T];
	return 0;
}

P1616
完全背包，正向来

#include<bits/stdc++.h>

using namespace std;
long long int dp[10000010];
int N,M,a,b;
int main()
{
     
	cin>>N>>M;
	for(int i=1;i<=M;i++)
	{
		cin>>a>>b;
		for(int j=a;j<=N;j++)
		{
			dp[j]=max(dp[j],dp[j-a]+b); 
		}
	 } 
	 cout<<dp[N];
	 return 0;
 } 

P1802
这个就是多加个判断，不同情况下不同策略，有的有的选，有的没得选

#include<iostream>
using namespace std;
long long int f[10086];
struct node
{
	int lose;
	int win;
	int ge;
}aa[10086];
int main()
{
	int n,x;
	cin>>n>>x;
	for(int i=1;i<=n;i++)
	{
		int a,b,c; 
		cin>>a>>b>>c;
		aa[i].lose =a;
		aa[i].win =b;
		aa[i].ge =c;
	}
	for(int i=1;i<=n;i++)
	{
	  for(int j=x;j>=0;j--)
	  {
	  	if(j>=aa[i].ge )
	  	{
	  	  f[j]=max(f[j]+aa[i].lose ,f[j-aa[i].ge ]+aa[i].win );
		  }
		  else
		  {
		  	f[j]=f[j]+aa[i].lose ;
		  }
	  }
	}
	cout<<f[x]*5;
	
}

P1002

#include<iostream>
using namespace std;
int a[25][25]={0},xb,yb,xm,ym;
long long int dp[23][23];
int main()
{
    //dp[2][2]=1;
	//dp[1][1]=1;
	dp[2][1]=1;
	
	cin>>xb>>yb>>xm>>ym;
	a[xm-2+2][ym-1+2]=1;
	a[xm-1+2][ym-2+2]=1;
	a[xm+1+2][ym-2+2]=1;
	a[xm+2+2][ym-1+2]=1;
	a[xm-1+2][ym+2+2]=1;
	a[xm+1+2][ym+2+2]=1;
	a[xm+2+2][ym+1+2]=1;
	a[xm-2+2][ym+1+2]=1;
	a[xm+2][ym+2]=1; 
	
		for(int i=2;i<=xb+2;i++)
	{
		for(int j=2;j<=yb+2;j++)
		{
		if(!a[i][j])
		 dp[i][j]=dp[i-1][j]+dp[i][j-1];
		else 
		 continue;
		}
	}
	cout<<dp[xb+2][yb+2];
	return 0;
}

注意为了防止越界往右下方挪动了，如果到了一点没有被占领，那就是加上到达这个点的两种可能性的可能，这种算累积的要用加法

P1434
首先肯定要在四周，并且要比自己短的，所以可以用深搜，然后保存下最大的，为了优化，记忆化搜索，数组存下来，之前搜过就直接返回

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int n,m,a[201][201],s[201][201],ans;
bool use[201][201];//这个就是所谓的不需要
int dfs(int x,int y){
    if(s[x][y])return s[x][y];//记忆化搜索
    s[x][y]=1;//题目中答案是有包含这个点的
    for(int i=0;i<4;i++)
    {  int xx=dx[i]+x;
       int yy=dy[i]+y;//四个方向
       if(xx>0&&yy>0&&xx<=n&&yy<=m&&a[x][y]>a[xx][yy]){
       	  dfs(xx,yy);
          s[x][y]=max(s[x][y],s[xx][yy]+1);
       }
    }
    return s[x][y];
}
int main()
{	
   scanf("%d%d",&n,&m);//同题目的R,C
   for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
       scanf("%d",&a[i][j]);
    for(int i=1;i<=n;i++)//找从每个出发的最长距离
      for(int j=1;j<=m;j++)
        ans=max(ans,dfs(i,j));//取最大值
    printf("%d",ans);
    return 0;
}

也可以dp，每一步的最大值是周围四个方向的最大的那个+1，初始化长度都是1，用优先队列的话就可以保证了无后续性，先算最低的点，取，然后和四周的比较高度，如果高的话，就是他们这中最多的+1；

#include<iostream>
#include<queue>
using namespace std;
struct node{
    int i,j,num,f;
};//结构体存点
struct cmp1{
    bool operator()(node x,node y){
        return x.num>y.num;
    }
};//优先队列小的在前面
priority_queue<node,vector<node>,cmp1>q;//stl大法好
int n,m,maxn,maxj,maxi,w,top=0,g[101][101],f[101][101];
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
        	f[i][j]=1;//长度最开始为1，它自己
            cin>>g[i][j];
            node a;
            a.i=i;a.j=j;a.f=0;a.num=g[i][j];
            q.push(a);//入队
        }
    }
    while(!q.empty()){
        node now1=q.top();//取点
        int i=now1.i;
        int j=now1.j;//坐标
        int now=now1.num;//此点的权值
        q.pop();//出队
        if(g[i-1][j]<now) f[i][j]=max(f[i][j],f[i-1][j]+1);
            if(g[i+1][j]<now) f[i][j]=max(f[i][j],f[i+1][j]+1);
            if(g[i][j-1]<now) f[i][j]=max(f[i][j],f[i][j-1]+1);
            if(g[i][j+1]<now) f[i][j]=max(f[i][j],f[i][j+1]+1);//dp
            if(maxn<f[i][j]) maxn=f[i][j];//取最大值
    }
    cout<<maxn;//输出
    return 0;//第一篇题解，请多支持！
}

这个结构体也很秒，存了位置，大小，