算法和数据操作—动态规划

一、把数字翻译成字符串（46）

题目要求：

给定一个数字，按照如下规则翻译成字符串：0翻译成“a”，1翻译成“b”...25翻译成“z”。一个数字有多种翻译可能，例如12258一共有5种，分别是bccfi，bwfi，bczi，mcfi，mzi。实现一个函数，用来计算一个数字有多少种不同的翻译方法。

解题思路：

下面我们从自上而下和自下而上两种角度分析这道题目，以12258为例：

自上而下，从最大的问题开始，递归 ：
                     12258
                   /       \
              b+2258       m+258
              /   \         /   \
          bc+258 bw+58  mc+58  mz+8
          /  \      \        \     \
      bcc+58 bcz+8   bwf+8   mcf+8  mzi
        /        \       \     \
   bccf+8        bczi    bwfi   mcfi
     /
 bccfi
有很多子问题被多次计算，比如258被翻译成几种这个子问题就被计算了两次。
 
自下而上，动态规划，从最小的问题开始 ：

f(r)表示以 r 为开始（r最小取0）到最右端所组成的数字能够翻译成字符串的种数。对于长度为 n 的数字，f(n)=0,f(n-1)=1,求f(0)。
递推公式为 f(r-2) = f(r-1)+g(r-2,r-1)*f(r)；

其中，如果r-2，r-1能够翻译成字符，则g(r-2,r-1)=1，否则为0。

因此，对于12258：
f(5) = 0
f(4) = 1
f(3) = f(4)+0 = 1
f(2) = f(3)+f(4) = 2
f(1) = f(2)+f(3) = 3 
f(0) = f(1)+f(2) = 5

#include <iostream>
#include <string>

using namespace std;

int getTranslationCount(const string &number);

int getTranslationCount(int number) {
	if (number < 0)
		return 0;
	string numberString = to_string(number);
	return getTranslationCount(numberString);
}

int getTranslationCount(const string &number) {
	int length = number.length();
	int *f = new int[length];
	int count = 0;

	for (int i = length - 1; i >= 0; --i)
	{
		count = 0;
		if (i < length - 1)
			count = f[i + 1];
		else
			count = 1;
		if (i < length - 1)
		{
			int digit1 = number[i] - '0';
			int digit2 = number[i + 1] - '0';
			int converted = digit1 * 10 + digit2;
			if (converted >=10&&converted<=25)
			{
				if (i < length - 2)
					count += f[i + 2];
				else
					count += 1;
			}
		}
		f[i] = count;
	}
	count = f[0];
	delete[] f;

	return count;
}

---

二、礼物的最大价值（47）

在一个m*n的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向左或者向下移动一格，知道到达棋盘的右下角。给定一个棋盘及其上面的礼物，请计算你最多能拿多少价值的礼物？

思路

一、利用循环的动态规划

1. 定义f(i, j)表示到达坐标为(i, j)的格子时能拿到的礼物总和的最大值；
2. 有两种路径到达(i, j)：（i-1,j）或者（i, j-1）；
3. f(i, j) = max(f(i-1, j), f(i, j-1)) + gift[i, j]；
4. 使用循环来计算避免重复子问题。

二、优化空间复杂度，使用一维数组

　　每次计算拿到的礼物最大值的时候，最大值的坐标只依赖 (i-1, j) 和 (i, j-1) 两个格子，因此第 i-2 行及以上所有的格子礼物最大值没有必要保存下来，因此可以用一维数组代替二维数组，一维数组的长度为棋盘的列数，当我们计算坐标为 (i, j) 格子能够拿到礼物的最大价值 f(i, j) 的时候，数组前j个数字分别是f(i, 0), f(i, 1)..., f(i, j-1)，数组从下标为 j 的数字开始到最后一个数字，分别为f(i-1,j),f(i-1,j+1),...,f(i-1,n-1)，也就是数组前面j个数字分别是当前第 i 行前面 j 个格子礼物的最大值，而后的数字分别保存前面第 i-1 行 n-j 个格子礼物的最大值。

---

三、最长不含重复字符的子字符串（48）

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。假设字符串中只包含从’a’到’z’的字符。例如，在字符串中”arabcacfr”，最长非重复子字符串为”acfr”，长度为4。

思路:

动态规划，用 f(i) 表示以 i 个字符结尾不包含重复子字符串的最长长度，从左向右扫描分两种情况：

1.若当前字符第一次出现，则最长非重复子字符串长度f(i) = f(i-1)+1。 

2.若当前字符不是第一次出现，则首先计算当前字符与它上次出现位置之间的距离d。

• 若d大于f(i-1)，即说明前一个非重复子字符串中没有包含当前字符，则可以添加当前字符到前一个非重复子字符串中，所以，f(i) = f(i-1)+1。
• 若d小于或等于f(i-1)，即说明前一个非重复子字符串中已经包含当前字符，则不可以添加当前字符，所以，f(i) = d。

例如：arabcacfr

f(0) =1,  a

f(1) = 2,  ar

f(2) = 2,  ra，因为d=2，f(1)=2，所以上一个a在f(1)之中

f(3) = 3,  rab

f(4) = 4,  rabc

f(5) = 3,  bca，因为d=3，f(1)=4，所以上一个a一定在f(4)中

f(6) = 2,  ac

f(7) = 3,  acf

f(8) = 4,  acfr，因为d=7,f(7)=3,因此上一个r不在f(7)中，f(8) = f(7) + 1

关键点：动态规划，两个重复字符的距离

int lengthOfLongestSubstring(const string &str) {
	int curLength = 0;
	int maxLength = 0;

	int *position = new int[26]; //记录上个字符出现的位置下标
	for (int i = 0; i < 26; ++i)
		position[i] = -1;
	for (int i = 0; i < str.length(); ++i)
	{
		int preIndex = position[str[i] - 'a'];
		if (preIndex < 0 || i - preIndex > curLength) //没出现过，或者d>f(i-1)
			++curLength;
		else                             // 出现过了
		{
			if (curLength > maxLength)
				maxLength = curLength;
			curLength = i - preIndex;   // f(i) = d
		}
		position[str[i] - 'a'] = i;
	}
	if (curLength > maxLength)
		maxLength = curLength;

	delete[] position;
	return maxLength;	
}