Week 4 动态规划入门

动规啊动规，你怎么可以这么难，哭了，从递归开始上强度了，哭死

B3637 最长上升子序列

一个数组a存数，一个数组f存当前位置的最长子序列的值

然后开始循环两层：如果后一个数字比前一个数大，那么就让该位的f[j]加一，加一后和上一位相比，如果比上一位大，那么此位的f[i]更新为上一位的值，如果不如上一位大，那么这里还是原来的最大值。最后比较一下f中的最大值，输出即可。

代码如下：

#include <iostream>
using namespace std;
int a[5010], f[5010];
int n,ans=0;
int main()
{
    scanf("%d", &n);
    for(int i=1; i<=n; i++) 
    {
        scanf("%d", &a[i]);
        f[i] = 1;
    }
    for(int i=1; i<=n; i++)
        for(int j=1; j<i; j++)
            if(a[j] < a[i])
                f[i] = max(f[i], f[j]+1);
    for(int i=1; i<=n; i++) 
        ans = max(ans, f[i]);
    printf("%d\n", ans);
    return 0;
}

P1115 最大子段和

这个题的思路和上个题类似，a存每一位数，b存每一位当前的最大子段和，然后通过循环比较出b中最大的字段和，然后输出。这里我引用一下这段思路是我从哪里抄来的：

代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,a[200020],b[200020],i,ans=-2147483647;

// b[i] 表示截止到 i 时，第 i 个数所在的有效序列的元素和。

int main(){
   cin>>n;
   for(i=1;i<=n;i++){
       cin>>a[i];
       if(i==1) b[i]=a[i];
       else b[i]=max(a[i],b[i-1]+a[i]);
       ans=max(ans,b[i]);
   }
   cout<<ans;
   return 0;
}

P8707  走方格

简单的递推，代码如下，思路就写在注释里了，把第一行和第一列初始化为1的原因是因为，从（1，1）开始只能向右/下走，只有1种方案到达这里。

#include<bits/stdc++.h>
#define ri register int
using namespace std;
int n,m,f[35][35];
int main() {
	cin>>n>>m;
	for(ri i=1;i<=n;i++)f[i][1]=1;
	for(ri j=1;j<=m;j++)f[1][j]=1;
	//从起始点到第一行和第一列的方案数都为 1 
	for(ri i=2;i<=n;i++){
		for(ri j=2;j<=m;j++){
			if(i%2==0&&j%2==0)f[i][j]=0;//不能进入：将方案数赋为 0 
			else f[i][j]=f[i-1][j]+f[i][j-1];//能进入：计算从左和从上走到当前位置的方案数 
		}
	}
	cout<<f[n][m];//输出答案 
	return 0;
}

P1216 数字三角形

思路就是老师视频里说的，自顶向下分析，自底向上计算。

代码如下：

#include<iostream> 
#include<cstdio> 
#include<cmath> 
using namespace std;  
int n;  
int a[1000][1000];  
int main()  
{       
	scanf("%d",&n);  
	for(int i=0;i<n;i++)  
	for(int j=0;j<=i;j++)  
	scanf("%d",&a[i][j]);//以上输入  
	for(int i=n-2;i>=0;i--)   
	{  
 		for(int j=0;j<=i;j++)//for循环按顺序扫描除最后一排前的所有数  
		a[i][j]+=max(a[i+1][j],a[i+1][j+1]); 
        //从左下，右下中选取大的加到现在的位置上 
    } 
    cout<<a[0][0]<<endl; 
    return 0; 
 }

P1020  导弹拦截

这道题不太会，抄的题解，我写一下自己理解的思路吧。

根据题意可知，由于这套系统后一次的高度不能高于前一次的高度，因此它拦截下来的导弹的高度一定是不上升的。而为了要拦截更多的导弹，我们要使得这个序列尽可能的长。于是问题便转化为求最长不上升子序列。

既然要最少的系统，我们对于每一套系统都要“用干净”，即尽量多次使用，避免浪费。很容易想到用贪心了。每一次从已有的系统里找第一个大于等于当前高度 a[i]的系统（一定要用符合条件且最小的，大的要尽量留着给后面用），并更新当前系统的高度。若找不到这样的系统，则需要一个新的系统，并且高度为 a[i]。不难发现，存储系统高度的数组也是单调不下降的，因此也可以使用二分优化查询过程。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n,ma,d[100001],a[100001],k,x[100001],xl=1,t,len=1;
int main()
{
	ios::sync_with_stdio(false);
	x[1]=0x7fffffff;
	while(cin>>a[++n]);
	d[1]=a[1];
	for(int i=2;i<=n;i++)
	{
		if(a[i]<=d[len]) d[++len]=a[i];
		else d[upper_bound(d+1,d+len+1,a[i],greater<int>())-d]=a[i];
	}
	cout<<len-1<<endl;
	for(int i=1;i<=n;i++)
	{
		t=0;
		if(x[xl]<a[i])
		{
			xl++;
			x[xl]=a[i];
		}
		else
		{
			int k=lower_bound(x+1,x+xl+1,a[i])-x;
			x[k]=a[i];
		}
	}
	cout<<xl;
	return 0;
}