leetcode-91-解码方法（动态规划和递归两种解法）
题目描述：
一条包含字母 A-Z 的消息通过以下方式进行了编码：
'A' -> 1
'B' -> 2
...
'Z' -> 26
给定一个只包含数字的非空字符串，请计算解码方法的总数。
示例 1:
输入: "12"
输出: 2
解释: 它可以解码为 "AB"（1 2）或者 "L"（12）。
示例 2:
输入: "226"
输出: 3
解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
要完成的函数：
int numDecodings(string s)
说明：
1、这道题给定一个字符串，字符串中只含有数字，数字1可以解码为A，数字2可以解码为B……数字26可以解码为Z。
要求判断有多少种解码的方式，最终返回解码方式的个数。
比如[2,2,6]，那么可以解码为2-2-6也就是BBF，也可以解码为2-26也就是BZ，也可以解码为26-2也就是ZB。
一共三种解码方式，最终返回3。
2、这道题有两种做法，一种是动态规划，另一种是递归。
动态规划比较快，可以beats 100.00% of cpp submissions，而递归只能beats 2.67% of cpp submissions。笔者把两种做法都实现了一下，附在下文。
我们先看一下动态规划的思路，动态规划关键在于每个阶段状态的把握。
举个例子，比如12224，我们首先对第一位，只能1这种解码方法。
对第二位2，可以1-2（独立），也可以12（合并），两种解码方法。
对第三位2，可以1-2-2（独立），也可以12-2（独立），也可以1-22（合并），三种解码方法。
在这一步我们发现其实到当前位为止的解码方法个数，就是上一步的解码方法个数（在后面直接添加独立的一位）+上一步独立的个数（当然这里要判断能不能合并在一起）。
所以我们只需要记住上一步的解码方法个数和上一步的独立的个数，就可以分不同阶段去处理。
再接下来对第四位2，可以1-2-2-2，也可以12-2-2，也可以1-22-2，这三个都是直接在后面添加独立的一位，也可以1-2-22，也可以12-22，这两个就是把先前独立的一位给合并了，所以当前总的解码个数是3+2=5，当前独立的个数就是3，也是上一步的总解码个数。
过程如下：
| 1 | 2 | 2 | 2 | ||
| 独立可合并下一位的个数 | 1 | 1 | 2 | 3 | |
| 总的解码方式的个数 | 1 | 2 | 3 | 5 | |
| 当前例子 | 1 |
1-2 12 |
1-2-2 12-2 1-22 |
1-2-2-2 12-2 1-22-2 1-2-22 12-22 |
|
规律十分清晰，但我们还有一个情况没有考虑到，就是可能会出现数字0。
比如110，第二个1这一步，当前总的解码方式有1-1和11，两种，独立可合并下一位的个数有一种。
然后到了0这一步，只能合并了，于是总的解码方式变成上一步独立可合并下一位的个数1，解码方式是1-10，当前这一位的独立可合并个数清空为0。
那还有不能合并的呢，比如130，3这一步，仍然是1-3和13，总的有2种，独立的有1种。
到0这一步，不能合并，于是总的解码方式变成0，完全不能解码，返回0。
所以，构造代码如下：（附详解）
int numDecodings(string s)
{
if(s[0]=='0')return 0;//边界条件，如果第一位是字符0，那么完全不能解码，直接返回0
int t1=1,t2=1,sum1,t3;//t1表示当前独立可合并下一位的个数，t2表示当前总的解码方式的个数
for(int i=1;i<s.size();i++)//从第二位开始处理
{
sum1=(s[i-1]-'0')*10+s[i]-'0';//如果跟前一位合并，计算合并之后的数值
if(sum1>=1&&sum1<=26)//如果数值符合条件，那么可以合并
{
if(s[i]!='0')//当前位不是0，那么t2加上t1的值，t1变成原本t2的值
{
t3=t2;
t2+=t1;
t1=t3;
}
else//当前位是0，比如10这种情况，那么t2变成t1的值，t1清空
{
t2=t1;
t1=0;
}
}
else//如果计算出来不能合并
{
if(s[i]!='0')//如果当前位不是0，比如227，后面的27就不能合并，于是t2不变，t1变成t2的数值
t1=t2;
else//如果当前位是0，又不能合并，比如30这种情况，那么直接返回0
return 0;
}
}
return t2;//最终返回t2这个总的解码方式的个数
}
上述代码实测0ms，beats 100.00% of cpp submissions。
如果有时间的话可以再看一下递归的做法，笔者最开始也是递归的思路，不断地试探，这种思路比较熟悉。
没时间的话就算啦，下面的文字可以直接略过。
举个例子[2,2,2,2,2]，我们先不断递归，逐个处理，直至超出范围，此时我们次数+1。
接着回退到上一层，也就是最后一个2，发现不能跟下一个数合并，于是再退到上一层，也就是倒数第二个2。
在这个时候发现可以合并，于是进入递归，但这时候下一个处理的数的位置要+2，而不是逐个处理。
接着再回退到上一层，发现第三个2和倒数第二个2可以合并，于是进入递归，这时候下一个要处理的数的位置+2，到达最后一个2那里。
……
我们可以总结出递归的操作，对于每一位而言，分两个步骤：
①进入对下一位的递归处理。
②结束①之后，判断能否与下一位合并，进入对下下位的递归处理。
所以我们可以构造出如下代码：
int count=0,t;//全局变量
void digui(string& s,int index)
{
if(index==s.size())//如果超出了范围,说明当前的尝试是成功的
{
count++;
return;
}
digui(s,index+1);//第一个步骤
t=(s[index]-'0')*10+s[index+1]-'0';//第二个步骤
if(index+1<s.size()&&t<=26&&t>=1)
digui(s,index+2);
}
int numDecodings(string s)
{
digui(s,0);
return count;
}
上述代码可以解决大部分情况，但是对于0的存在无能为力。比如10，只有一种解码方式，但按照上述代码，返回结果是2。
但其实处理到0这一位的时候，当前尝试是失败的，应该结束这种尝试。
所以我们稍微修改一下代码，如下：
int count=0,t;
void digui(string& s,int index)
{
if(s[index]=='0')//增加了对于0的判断
return;
if(index==s.size())
{
count++;
return;
}
digui(s,index+1);
t=(s[index]-'0')*10+s[index+1]-'0';
if(index+1<s.size()&&t<=26&&t>=1)
digui(s,index+2);
}
int numDecodings(string s)
{
digui(s,0);
return count;
}
上述代码可以通过测试，但是实测484ms，beats 2.67% of cpp submissions。递归太耗时间了。
