PTA 青蛙过桥 (30分)(动态规划)

一座长度为n的桥，起点的一端坐标为0，且在整数坐标i处有a[i]个石头【0<=a[i]<=4】， 一只青蛙从坐标0处开始起跳，一步可以跳的距离为1或2或3【即每一步都会落在整数点处】， 青蛙落在i处会踩着该点的所有石头，求青蛙跳出这座桥最少踩多少个石头？并且输出依次跳 过的坐标点路线，如果存在多种路线，输出字典序最小的那一条。

输入格式:

第一行整数n(<150000)，接着下一行会有n+1个由空格隔开的整数,即桥上各个坐标处石头数量。

输出格式:

第一行为踩着最少石头个数，第二行为依次跳过的坐标点【字典序最小的】。

输入样例:

在这里给出两组输入。例如：

10
1 2 1 3 0 3 1 2 1 1 2

100
1 2 0 4 0 1 3 4 2 2 1 3 1 4 0 3 0 1 2 3 3 2 2 0 1 0 0 0 0 1 2 1 3 4 0 3 4 4 1 0
4 1 3 1 1 2 3 4 4 4 0 2 0 1 1 1 3 1 3 2 1 2 4 1 2 1 4 1 0 0 1 2 3 0 2 4 4 0 0 4
2 0 0 2 1 3 3 3 0 0 2 0 0 1 2 4 2 2 2 4 0

输出样例:

在这里给出对应的输出。例如：

4
0 2 4 6 8

36
0 2 4 5 8 10 12 14 16 17 20 23 25 26 27 28 31 34 35 38 39 41 44 47 50 52 54 57 60 63 65 68 69 70 73 74 77 78 81 82 85 88 89 91 92 94 97 100

解题

动态规划的状态转换方程简单，dp[n] = min{dp[n], dp[n - i] + a[n]} (1 =< i <= 3) dp[n]表示跳到n位置的最少石头数, 在这里设a[n +1] = 0，那么最终要求的最优解就是dp[n +1]（>>很好理解的<<）
然而这题的一个难点就是输出路径并如果存在多种路线，输出字典序最小的那一条。问题是怎么输出字典序最小的路径???
首先要记录路径，我们会想到用一个path[]数组记录路径，一开始想要记录字典序最小就要优先选择位置靠前的。比如：

当我们以为这道题就可以轻松解决时，会发现这个算法是错误的。
如果dp[n - 1]前面的路径唯一且是0, 2, 3, …, n - 1; 而dp[n - 2]前面的路径唯一且是0, 2, 4, …, n - 2; 显然dp[n - 1]的字典序更小，而在上述算法中我们选择了更大的，这就不符合题意了。
这是我们就会想能不能每次选择前，都知道各个dp[k] ( k < n)的字典序的大小情况。
在这里，引入一个新的数组len[]，表示青蛙跳到该步时的经过的站次数（记len[0] = 1），于是当每次发现求dp[n]有多个选择时，我们总是选择len[]的较大者，当然如果len相等就选择编号小的。
为什么要选择len[]较大的？？
要加入的数的字典序最大，len越小，大的数越靠前，字典序越大。
如果当n = 9时，而dp[8] = dp[7]，len[8] > len[7]，此时应选dp[8]。由dp[8] == dp[7]可知，必存在k < 8 使得dp[k] <= dp[8]，在这里假设len[8] = len[7] + 1，于是len[k] = len[7]，现在只需证明k <= 7时选择8即可（自行理解），因为k的长度与7的长度相等。
显然k = 7时，选8。k < 7时，由于长度相等，自然越小的包括的小的数越多越靠前。（有点瞎鸡儿证明>>>）
现在推广len[8] = len[7] + t，t > 2, 。。。。（算了）
代码：

#include <iostream>					//7-70 青蛙过桥 (30分)
#include <algorithm>
#include <cstring>
#include <stack>
using namespace std;
const int maxn = 1.5e5 + 2;
typedef long long ll;
ll a[maxn], dp[maxn];
ll path[maxn], len[maxn];			//路径及路径长度

int main()
{
	int n;
	cin >> n;
	for (int i = 0; i <= n; i++)
		cin >> a[i];

	memset(dp, 0x3f, sizeof(dp));
	memset(path, -1, sizeof(path));
	dp[0] = a[0];
	len[0] = 1;

	for (int i = 1; i <= n + 1; i++)
		for (int j = 1; j <= 3 && i >= j; j++)
			if (dp[i] > dp[i - j] + a[i])
			{
				dp[i] = dp[i - j] + a[i];
				path[i] = i - j;
				len[i] = len[i - j] + 1;
			}
			else if(dp[i] == dp[i - j] + a[i]){
				if(len[i] <= len[i - j] + 1)		//注意是<=, 如果=选编号小的(这里先判断编号大的)
				{
					len[i] = len[i - j] + 1;
					path[i] = i - j;
				}
			}

	stack<ll> s;
	for (int i = n + 1; path[i] >= 0LL; i = path[i])
		s.push(path[i]);

	cout << dp[n + 1] << endl;
	while (!s.empty())
	{
		ll t = s.top();
		s.pop();
		if(s.empty())
			cout << t;
		else
			cout << t << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}