leetcode----------解码方法

一条包含字母 A-Z 的消息通过以下方式进行了编码：

'A' -> 1
'B' -> 2
...
'Z' -> 26

输入: "12"
输出: 2
解释: 它可以解码为 "AB"（1 2）或者 "L"（12）

输入: "226"
输出: 3
解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。

注意：如果出现"30"这种，则超出26，或着"00",则直接返回0

这一题，我刚开始想，这不就是一次走一步，或者一次走两步吗，但是细想，发现不对，对于"31"这种，就不能一次走1步;

刚开始我想用分治去解，结果发现，这么解根本行不通，因为左和右两端一结合，则右边的解码方式就全乱了，

于是我想这其实就是集合的表示形式;只不过有了一点规则而已;

比如:"226"

它有3种子集的表达方式：

{ {2} ，{2} ，{6} }

{ {22} ，{6} }

{ {2} ，{26} }

于是，这就是一种动态规划，根据走到了那一个字符，然后根据前面的集合来看，是否能加入一种新的集合方式;

如果在"226"后面还有一个"1";

从而这时就判断;它并不能和i-1 项合并，因此，只是加入到了刚才的每一个集合的末尾，并没有新的集合花样;

{ {2} ，{2} ，{6}  ，{ 1 } }

{ {22} ，{6} ，{ 1 } }

{ {2} ，{26} } ，{1} }

用数学公式描述就是dp[i]=dp[i-1];

但是如果是"2212";来到了最后一个字符"2";

之前的集合为：

{ {2} ，{2} ，{1} }

{ {22} ，{1} }

{ {2} ，{21} }

但是i-1 项能和2 合并，从而肯定会多出新的集合花样：

它正好是i-2项的集合花样末尾加上{12}   和 i-1 项的结合花样 末尾单独加上 {1} ;  这两种集合类型肯定不会重叠，因为一个是{1，2}这样的花样加入的，一个是以 {1 } ，{2} 这样的花样加入的;

此时用数学公式描述就是 dp[i]=dp[i-1]+dp[i-2];（这里我判断条件出错，怎么都不对，于是看了别人的判断，发现是这么个回事，当时我从集合的理解角度没能绕过来）

当然还有其他情况：

比如 "23"后面是"0";

此时就不能解码，直接返回0;

比如"22"后面是"0"

此时必须和i-1 项结合，不然就不能解码，从而dp[i]=dp[i-2]; (因为i-1项和i项合并，就相当与在i-2项的各集合末尾加上一个{20}，因此集合并没有新花样)

code：

class Solution {
public:    
    int numDecodings(string s) {
        int N=s.size();
        int dp[N]={0};
        if(N==0)    return 0;
        if(N==1){
            if(s[0]!='0'){
                return 1;
            }
            else return 0;
            }
        if(s[0]=='0') return 0;
        if(s[0]>'2'&&s[1]=='0') return 0;
        if(s[0]<'3'){
            if(s[0]=='2'&&s[1]>'6') {
                dp[0]=1;
                dp[1]=1;
            }
            else if(s[1]=='0'){
                dp[0]=1;
                dp[1]=1;
            }
            else {
                dp[0]=1;
                dp[1]=2;
            }
        }
        else {
            dp[0]=1;
            dp[1]=1;
        }
        if(N==2)    return dp[1];
        for(int i=2;i<N;++i)
        {
            if(s[i-1]=='0'&&s[i]=='0')  return 0;
            else if(s[i-1]=='0')    dp[i]=dp[i-1];  //集合并没有新花样
            else if(s[i-1]<'3'&&s[i]=='0')  dp[i]=dp[i-2];  //必须合并，则和dp[i-2]的集合一样，没新花样
            // 能合并,说明是i-1，i结合的一种集合类型+i是单独的一种集合类型
            else if((s[i-1]=='2'&&s[i]<='6')||s[i-1]=='1')   dp[i]=dp[i-2]+dp[i-1];      
            else if(s[i-1]>'2'&&s[i]=='0')    return 0;
            else dp[i]=dp[i-1];     //只是每个集合多了第i项，也就是集合未新增
        }
        return dp[N-1];
    }
};

 

时间复杂度：

遍历一边即可O(n)

空间复杂度 为 O(n)