线性 dp

P1052 过河

题意：求一只青蛙过独木桥，最少踩到的石子数
思路：设$dp[i]$表示青蛙在第i个点，踩过的石子数。能够得到转移方程
$$dp[i]=min(dp[i],dp[i-j]+flag[i]),(i-t\le j\le i-s)$$但是，题目中给出的L的范围很大，所以要根据两个石子之间的距离做离散化。当两颗石子的距离大于90时，设置为90。因为最多有100个石子，离散化之后，每两颗石子之间的最大距离为90，所以开一个9000大小的flag数组，记录离散化之后石子的位置即可

• 如果 S == T 的话，就不能随便离散化了。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+5;

int L,S,T,M;
int a[105],b[105];
int dp[3000],vis[3000];

int main()
{
    cin>>L>>S>>T>>M;
    for(int i=1; i<=M; ++i) cin>>a[i];
    sort(a+1,a+1+M);

    if(S==T)
    {
        int ans=0;
        for(int i=1; i<=M; ++i)
            if(a[i]%S==0) ans++;
        printf("%d\n",ans);
        return 0;
    }

    int now=0;
    for(int i=1; i<=M; ++i)
    {
        if(a[i]-a[i-1]>=20) b[i]=b[i-1]+20;
        else b[i]=b[i-1]+a[i]-a[i-1];
    }
    L=b[M]+20;
    for(int i=1; i<=M; ++i) vis[b[i]]=1;
    memset(dp,0x3f,sizeof(dp));
    dp[0]=0;
    for(int i=0; i<=L; ++i)
    {
        for(int j=S; j<=T; ++j)
        {
            dp[i+j]=min(dp[i+j],dp[i]+vis[i+j]);
        }
    }
    printf("%d\n",dp[L]);
    return 0;
}

最大子段和

思路：每次加一个数时，统计最大值。遇到负数清零即可

	for(int i=1;i<=n;++i)
	{
		if(sum+a[i]<0)
			sum=0;
		else 
			sum+=a[i];
		ans=max(ans,sum);	
	}

To the Max POJ - 1050

题意：矩阵中和最大的矩阵
思路：计算出前缀和，枚举上下两条边，转变成一维计算

#include <cstdio>
#include <algorithm>
#define ll long long
using namespace std;
const int maxn=1e5+5;

int n,a[105][105];

int main()
{
    scanf("%d",&n);
    for(int i=1; i<=n; ++i)
        for(int j=1; j<=n; ++j)
        {
            scanf("%d",&a[i][j]);
            a[i][j]+=a[i-1][j];
        }
    int ans=0;
    for(int i=1; i<=n; ++i)
    {
        for(int j=i; j<=n; ++j)
        {
            int sum=0;
            for(int k=1; k<=n; ++k)
            {
                sum+=a[j][k]-a[i-1][k];
                if(sum<0) sum=0;
                ans=max(ans,sum);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

Max Sum Plus Plus HDU - 1024

题意 求m个字段的最大和
思路 设 $dp[i][j]$ 表示选取了第i个数（已经加入），组成j个子段的最大和
$dp[i][j]$的转移有两种情况：
1、在一个连续子段中加入第 i 个数
2、前一个子段的最后一位是k，然后以 i 作为新一个子段的开头
转移方程$$dp[i][j]=max(dp[i-1][j],dp[k][j-1])+a[i]$$

这样就得到了最暴力的$O(n^3)$的做法，这样肯定会超时，而且空间可能也不够

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#define rep(i,a,b) for (int i=a; i<=b; ++i)
#define per(i,b,a) for (int i=b; i>=a; --i)
#define mes(a,b)  memset(a,b,sizeof(a))
using namespace std;
const int maxn=1e6+5,INF=0x3f3f3f3f;

int n,m,a[maxn]; 
int dp[100][100];

int main()
{
	while(cin>>m>>n)
	{
		rep(i,1,n)
		{
			cin>>a[i];		
		}
		mes(dp,0);
		
		int ans=-INF;
		for(int j=1;j<=m;++j)
		{
			for(int i=j;i<=n;++i)
			{
				for(int k=j-1;k<=i-2;++k)
				{
					dp[i][j]=max(dp[i][j],dp[k][j-1]);
				}
				dp[i][j]=max(dp[i][j],dp[i-1][j])+a[i];
				ans=max(dp[i][j],ans);
			}
		} 
		cout<<ans<<"\n";
	}    
	return 0;
}

观察转移方程，可以发现，其实我们并不需要确切的知道k的具体值。只需要用 $pre[i-1]$ 记录一下 $[1,i-2]$ 这个区间的子段和最大值即可
$$dp[i][j]=max(dp[i-1][j],dp[k][j-1])+a[i]$$

那么，为什么是$[1,i-2]$,而不是$[1,i-1]$呢？
因为，$dp[i][j]$表示的是选取了第 $i$ 个数，组成了 $j$ 个子段的最大和，如果记录到$dp[i-1][j-1]$的话，它表示的是选取了第$i-1$个数，组成了$j-1$个子段最大和，在加上第i个数，依旧是$j-1$个子段。这与$j$个子段相矛盾，所以只能取到 $i-2$

#include <iostream>
#include <algorithm>
#include <cstring>
#define rep(i,a,b) for (int i=a; i<=b; ++i)
#define per(i,b,a) for (int i=b; i>=a; --i)
#define mes(a,b)  memset(a,b,sizeof(a))
using namespace std;
const int maxn=1e6+5,INF=0x3f3f3f3f;
const int mod=1e9+7;

int n,m,a[maxn]; 
int dp[maxn],pre[maxn];

int main()
{
	while(cin>>m>>n)
	{
		rep(i,1,n)
		{
			cin>>a[i];	
			dp[i]=pre[i]=0;		
		}
		int ans;				
		for(int j=1;j<=m;++j)
		{
			ans=-INF;
			for(int i=j;i<=n;++i)
			{
				dp[i]=max(dp[i-1],pre[i-1])+a[i];
				pre[i-1]=ans;
				ans=max(ans,dp[i]);
			}
		}
		cout<<ans<<"\n";
	}
	return 0;
}