动态规划总结

登山

描述
五一到了，PKU-ACM队组织大家去登山观光，队员们发现山上一个有N个景点，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。队员们希望在满足上面条件的同时，尽可能多的浏览景点，你能帮他们找出最多可能浏览的景点数么？
输入
—-Line 1： N (2 <= N <= 1000) 景点数
—-Line 2： N个整数，每个景点的海拔
输出
最多能浏览的景点数
样例输入
8
186 186 150 200 160 130 197 220
样例输出
4

---

分析如下：
题目要求按顺序访问景点，上山一次，下山也可访问一次。

---

算法分析：
第一次，模拟上山，枚举每个点，找到编号从小到大，且海拔比该点低的序列长度最大值。（到达该点后下山）。
然后下山，找到编号从小到大，海拔比该点低的序列长度最大值。
最后综合一下，由于该点上山，下山，被重复计算两次，故-1。

---

代码如下：

    for(int i = 1; i<=n; i++) {
        cin>>b[i][1];
        b[i][2] = 1;
        b[i][3] = 1;
    }
    int l = 0;
    for(int i = n-1; i>=1; i--) {
        l = 0;
        for(int j = i+1; j<=n; j++) {
            if((b[j][1] < b[i][1]) && (b[j][2]>l)) {
                l = b[j][2];
            }
        }
        if(l) {
            b[i][2] = l + 1;
        }
    }
    for(int i = 2; i<=n; i++) {
        l = 0;
        for(int j = 1; j<=i-1; j++) {
            if((b[j][1] < b[i][1]) && (b[j][3]>l)) {
                l = b[j][3];
            }
        }
        if(l) {
            b[i][3] = l + 1;
        }
    }
    int maxn = 0;
    for(int i = 1; i<=n; i++) {
        int temp = b[i][2] + b[i][3];
        maxn = max(maxn,temp);
    }
    cout<<maxn-1;

---

摘花生

描述
Hello Kitty 想摘点花生送给她喜欢的米老鼠。她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。Hello Kitty只能向东或向南走，不能向西或向北走。问Hello Kitty 最多能够摘到多少颗花生。
输入
第一行是一个整数T，代表一共有多少组数据。1<=T <= 100
接下来是T组数据。
每组数据的第一行是两个整数，分别代表花生苗的行数R和列数 C ( 1<= R,C <=100)
每组数据的接下来R行数据，从北向南依次描述每行花生苗的情况。每行数据有 C 个整数，按从西向东的顺序描述了该行每株花生苗上的花生数目 M ( 0<= M <= 1000)。
输出
对每组输入数据，输出一行，内容为Hello Kitty能摘到得最多的花生颗数。

---

分析：只能向东或向南走（不然全部摘了多好），不要求输出路径，数据就不用担心被覆盖了。简单地分析，点（a,b）可能的来源点（a-1，b），点（a，b-1）。
代码就不用说了，基本的，f[i][j] = map[i][j] + max{ f[i-1][j] , f[i][j-1] };

#include<iostream>
#include<string.h>
using namespace std;
long long map[101][101];
long long f[101][101];
int m,n,t;
int main() {
    cin>>t;
    while(t) {
        t--;
        cin>>m>>n;
        for(int i = 1; i<=m; i++) {
            for(int j = 1; j<=n; j++) {
                cin>>map[i][j];
            }
        }
        for(int i = 1; i<=m; i++) {
            for(int j = 1; j<=n; j++) {
                if(j == 1 && i == 1) {
                    f[1][1] = map[1][1];
                } else {
                    f[i][j] = map[i][j] + max(f[i][j-1],f[i-1][j]);
                }
            }
        }
        cout<<f[m][n]<<endl;
    }
    return 0;
}

---

股票买卖

描述
最近越来越多的人都投身股市，阿福也有点心动了。谨记着“股市有风险，入市需谨慎”，阿福决定先来研究一下简化版的股票买卖问题。
假设阿福已经准确预测出了某只股票在未来 N
天的价格，他希望买卖两次，使得获得的利润最高。为了计算简单起见，利润的计算方式为卖出的价格减去买入的价格。
同一天可以进行多次买卖。但是在第一次买入之后，必须要先卖出，然后才可以第二次买入。 现在，阿福想知道他最多可以获得多少利润。
输入
输入的第一行是一个整数 T (T <= 50) ，表示一共有 T 组数据。
接下来的每组数据，第一行是一个整数 N (1 <= N <= 100, 000) ，表示一共有 N 天。第二行是 N 个被空格分开的整数，表示每天该股票的价格。该股票每天的价格的绝对值均不会超过1,000,000 。
输出
对于每组数据，输出一行。该行包含一个整数，表示阿福能够获得的最大的利润。

---

分析：题目的数据很大，小心超时。
因为只想买卖两次，第一次先模拟买入。
假设先购买的第一天的股票，此时利润为0（当天卖出肯定利润为零），肯定想购入价低，卖出价高，没话说，只需查找第 i 天之前的最小值，与第 i 天的卖价相减，如果比之前的利润高，则买入。（其实我当时就想到了“登山问题”）。
找第二次买卖，假设购买第N天的股票，之后就同上了。

代码如下：

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#define MAXN 1000001
using namespace std;
int t,n;
int a[MAXN],mmax[MAXN],mmin[MAXN],profit1[MAXN],profit2[MAXN];
int main() {
    cin>>t;
    while(t) {
        t--;
        scanf("%d",&n);
        for(int i = 1; i<=n; i++) {
            scanf("%d",&a[i]);
        }
        mmin[1] = a[1];
        profit1[1] = 0;
        for(int i = 2; i<=n; i++) {
            mmin[i] = min(mmin[i-1],a[i]);
            profit1[i] = max(a[i] - mmin[i],profit1[i-1]);
        }
        mmax[n] = a[n];
        profit2[n] = 0;
        for(int i = n-1; i>=1; i--) {
            mmax[i] = max(mmax[i+1],a[i]);
            profit2[i] = max(profit2[n+1],mmax[i] - a[i]);
        }
        int maxn = 0;
        for(int i = 1; i<=n; i++) {
            maxn = max(maxn,profit1[i] + profit2[i]);
            a[i] = profit1[i] = profit2[i] = mmin[i] = mmax[i] = 0;
        }
        printf("%d\n",maxn);
    }
    return 0;
}

---

大盗阿福

描述
阿福是一名经验丰富的大盗。趁着月黑风高，阿福打算今晚洗劫一条街上的店铺。
这条街上一共有 N 家店铺，每家店中都有一些现金。阿福事先调查得知，只有当他同时洗劫了两家相邻的店铺时，街上的报警系统才会启动，然后警察就会蜂拥而至。
作为一向谨慎作案的大盗，阿福不愿意冒着被警察追捕的风险行窃。他想知道，在不惊动警察的情况下，他今晚最多可以得到多少现金？
输入
输入的第一行是一个整数 T (T <= 50) ，表示一共有 T 组数据。
接下来的每组数据，第一行是一个整数 N (1 <= N <= 100, 000) ，表示一共有 N 家店铺。第二行是 N 个被空格分开的正整数，表示每一家店铺中的现金数量。每家店铺中的现金数量均不超过 1000 。
输出
对于每组数据，输出一行。该行包含一个整数，表示阿福在不惊动警察的情况下可以得到的现金数量。

---

分析：
先简化问题吧，假设只有两家店，那么对于第一家店，无非偷与不偷，即f[1] = value[1];
f[2] = max{f[1] , f[0] + value[2]};//因为不能连续偷两家，故f[i-1]不要加value[i]。

代码：

#include<iostream>
using namespace std;
int k,n,value[1000001],f[1000001];
int main() {
    scanf("%d",&k);
    while(k) {
        k--;
        scanf("%d",&n);
        for(int i = 1; i<=n; i++) {
            scanf("%d",&value[i]);
        }
        f[1] = value[1];
        for(int i = 2; i<=n; i++) {
            f[i] = max(f[i-1],f[i-2] + value[i]);
        }
        printf("%d\n",f[n]);
    }
    return 0;
}