（算法）解码⽅法————＜动态规划＞

1. 题⽬链接：91.解码⽅法

2. 题⽬描述：

3. 解法（动态规划）：

算法思路：

类似于斐波那契数列~ 

1. 状态表⽰：

根据以往的经验，对于⼤多数线性dp ，我们经验上都是「以某个位置结束或者开始」做⽂章，这⾥我们继续尝试「⽤i位置为结尾」结合「题⽬要求」来定义状态表⽰。

dp[i] 表⽰：字符串中[0，i] 区间上，⼀共有多少种编码⽅法。

2. 状态转移⽅程：

定义好状态表⽰，我们就可以分析i 位置的dp 值，如何由「前⾯」或者「后⾯」的信息推导出 来。

关于i 位置的编码状况，我们可以分为下⾯两种情况：

                i. 让i 位置上的数单独解码成⼀个字⺟；

                ii. 让i 位置上的数与i - 1 位置上的数结合，解码成⼀个字⺟。

下⾯我们就上⾯的两种解码情况，继续分析：

        ◦ 让i位置上的数单独解码成⼀个字⺟，就存在「解码成功」和「解码失败」两种情况：

                i. 解码成功：当i 位置上的数在[1, 9] 之间的时候，说明i 位置上的数是可以单独解 码的，那么此时[0, i] 区间上的解码⽅法应该等于[0, i - 1] 区间上的解码⽅ 法。

因为[0, i - 1] 区间上的所有解码结果，后⾯填上⼀个i 位置解码后的字⺟就 可以了。此时dp[i] = dp[i - 1] ；

                ii. 解码失败：当i 位置上的数是0 的时候，说明i 位置上的数是不能单独解码的，那么 此时[0, i] 区间上不存在解码⽅法。因为i 位置如果单独参与解码，但是解码失败 了，那么前⾯做的努⼒就全部⽩费了。此时dp[i] = 0 。

        ◦ 让i 位置上的数与i - 1 位置上的数结合在⼀起，解码成⼀个字⺟，也存在「解码成功」 和「解码失败」两种情况：

                i. 解码成功：当结合的数在[10, 26] 之间的时候，说明[i - 1, i] 两个位置是可以 解码成功的，那么此时[0, i] 区间上的解码⽅法应该等于[0, i - 2 ]区间上的解码 ⽅法，原因同上。此时dp[i] = dp[i - 2] ； 

                ii. 解码失败：当结合的数在[0, 9] 和[27 , 99] 之间的时候，说明两个位置结合后解 码失败（这⾥⼀定要注意00 01 02 03 04 ......这⼏种情况），那么此时[0, i] 区 间上的解码⽅法就不存在了，原因依旧同上。此时dp[i] = 0 。 

综上所述： dp[i] 最终的结果应该是上⾯四种情况下，解码成功的两种的累加和（因为我们关⼼ 的是解码⽅法，既然解码失败，就不⽤加⼊到最终结果中去），因此可以得到状态转移⽅程 （ dp[i] 默认初始化为0 ）： 

                i. 当s[i] 上的数在[1, 9] 区间上时： dp[i] += dp[i - 1] ；

                ii. 当s[i - 1] 与s[i] 上的数结合后，在[10, 26] 之间的时候： dp[i] += dp[i - 2] ； 如果上述两个判断都不成⽴，说明没有解码⽅法， dp[i] 就是默认值0 。

3. 初始化：

⽅法⼀（直接初始化）：

由于可能要⽤到i - 1 以及i - 2 位置上的dp 值，因此要先初始化「前两个位置」。

初始化dp[0] ： 

        i. 当s[0] == '0' 时，没有编码⽅法，结果dp[0] = 0 ；

        ii. 当s[0] != '0' 时，能编码成功， dp[0] = 1

初始化dp[1] ：

        i. 当s[1] 在[1，9] 之间时，能单独编码，此时dp[1] += dp[0] （原因同上， dp[1] 默认为0 ）

        ii. 当s[0] 与s[1] 结合后的数在[10, 26] 之间时，说明在前两个字符中，⼜有⼀种 编码⽅式，此时dp[1] += 1

⽅法⼆（添加辅助位置初始化）：

可以在最前⾯加上⼀个辅助结点，帮助我们初始化。

使⽤这种技巧要注意两个点：

        i. 辅助结点⾥⾯的值要保证后续填表是正确的；

        ii. 下标的映射关系

4. 填表顺序：

毫⽆疑问是「从左往右」

5. 返回值：

应该返回dp[n - 1] 的值，表⽰在[0, n - 1] 区间上的编码⽅法。

C++算法代码：

使⽤直接初始化的⽅式解决问题：  

class Solution
{
public:
	int numDecodings(string s)
	{
		int n = s.size();
		vector<int> dp(n); // 创建⼀个 dp表 
		// 初始化前两个位置 
		dp[0] = s[0] != '0';
		if (n == 1) return dp[0]; // 处理边界情况 
		if (s[1] <= '9' && s[1] >= '1') dp[1] += dp[0];
		int t = (s[0] - '0') * 10 + s[1] - '0';
		if (t >= 10 && t <= 26) dp[1] += 1;
		// 填表 
		for (int i = 2; i < n; i++)
		{
			// 如果单独编码 
			if (s[i] <= '9' && s[i] >= '1') dp[i] += dp[i - 1];
			// 如果和前⾯的⼀个数联合起来编码 
			int t = (s[i - 1] - '0') * 10 + s[i] - '0';
			if (t >= 10 && t <= 26) dp[i] += dp[i - 2];
		}
		// 返回结果 
		return dp[n - 1];
	}
};

使⽤添加辅助结点的⽅式初始化：

class Solution
{
public:
	int numDecodings(string s)
	{
		// 优化 
		int n = s.size();
		vector<int> dp(n + 1);
		dp[0] = 1; // 保证后续填表是正确的 
		dp[1] = s[0] != '0';
		// 填表 
		for (int i = 2; i <= n; i++)
		{
			// 处理单独编码 
			if (s[i - 1] != '0') dp[i] += dp[i - 1];
			// 如果和前⾯的⼀个数联合起来编码 
			int t = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
			if (t >= 10 && t <= 26) dp[i] += dp[i - 2];
		}
		return dp[n];
	}
};

Java算法代码：

使⽤直接初始化的⽅式解决问题：

class Solution
{
	public int numDecodings(String ss)
	{
		// 1. 创建 dp 表 
		// 2. 初始化 
		// 3. 填表 
		// 4. 返回值 
		int n = ss.length();
		char[] s = ss.toCharArray();
		int[] dp = new int[n];
		if (s[0] != '0') dp[0] = 1; // 初始化第⼀个位置 
		if (n == 1) return dp[0]; // 处理边界情况 
		// 初始化第⼆个位置 
		if (s[1] != '0' && s[0] != '0') dp[1] += 1;
		int t = (s[0] - '0') * 10 + s[1] - '0';
		if (t >= 10 && t <= 26) dp[1] += 1;
		for (int i = 2; i < n; i++)
		{
			// 先处理第⼀种情况 
			if (s[i] != '0') dp[i] += dp[i - 1];
			// 处理第⼆种情况 
			int tt = (s[i - 1] - '0') * 10 + s[i] - '0';
			if (tt >= 10 && tt <= 26) dp[i] += dp[i - 2];
		}
		return dp[n - 1];
	}
}

使⽤添加辅助结点的⽅式初始化：

class Solution
{
	public int numDecodings(String ss)
	{
		// 1. 创建 dp 表 
		// 2. 初始化 
		// 3. 填表 
		// 4. 返回值 
		int n = ss.length();
		char[] s = ss.toCharArray();
		int[] dp = new int[n + 1];
		dp[0] = 1; // 保证后续填表是正确的 
		if (s[1 - 1] != '0') dp[1] = 1;
		for (int i = 2; i <= n; i++)
		{
			// 先处理第⼀种情况 
			if (s[i - 1] != '0') dp[i] += dp[i - 1];
			// 处理第⼆种情况 
			int tt = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
			if (tt >= 10 && tt <= 26) dp[i] += dp[i - 2];
		}
		return dp[n];
	}
}