JAVA：尝试模型1：从左到右-字符串、数字的转换（暴力递归-到-动态规划）

				//尝试模型1：从左到右---字符串、数字的转换
								//暴力递归-到-动态规划
/*
 要求：规定1-A，2-B...，比如111-转换-AAA、AK、KA；
 条件：只给一个只有数字组成的字符串Str，返回有多少种转换结果
 */

public static void main(String[] args) {
	
	long start1 = System.currentTimeMillis();
	System.out.println(conversionViolence("241414242424212135122132112122544135422381213123123123132"));
	long end1 = System.currentTimeMillis();
	System.out.println("cosr time1:"+(end1-start1)+" ms");
	/*
	225607680
	cosr time1:2751 ms
	测试结果：数据一样，但动态规划运行快很多倍（尝试了调用动态规划很大数值（大到输出为负），仍然是0ms，）
	225607680
	cosr time2:0 ms
	 */
	
	long start2 = System.currentTimeMillis();
	System.out.println(conversionDynamic("241414242424212135122132112122544135422381213123123123132"));
	long end2 = System.currentTimeMillis();
	System.out.println("cosr time2:"+(end2-start2)+" ms");
}


										//暴力递归方法
public static int conversionViolence(String str) {
	if(str == null || str.length()==0) {					//输入字符串为空、字符长度为0
		return 0;
	}
	return conversion(str.toCharArray(), 0);		//调用暴力递归方法------递归调用输入为 0，所以动态规划起点为 length-1
}

//暴力递归方法具体实现									当前位置
public static int conversion(char[] str,int index) {
	if(index == str.length) {								//递归结束条件
		return 1;
	}
	if(str[index]=='0') {									//遇见0字符，直接退出（10的情况是另外一种可能，也会递归进行）
		return 0;
	}
	if(str[index]=='1') {								//当遇见1字符时，判断两种可能性（1后是否还有元素：分别转换、合并转换---'1n'永远在字符之中）
		int res = conversion(str,index+1);      //直接转换
		if((index+1)<str.length) {
			res += conversion(str,index+2);		//二个位置一起转换
		}
		return res;
	}
	if(str[index]=='2') {								
		int res = conversion(str,index+1);      //直接转换
		if(index+1<str.length && str[index+1]<='6' && str[index+1]>='0') {     //<=26有合并转换的可能性
			res += conversion(str, index+2);
		}
		return res;
	}
	return conversion(str, index+1);
}

										//动态规划方法
public static int conversionDynamic(String s) {
	if(s == null || s.length()==0) {						//输入字符串为空、字符长度为0
		return 0;
	}
	char[] str = s.toCharArray();							//转换成字符类型数组
	int[] dp = new int[str.length+1]; 						//创建存储每次递归值的数组dp
	dp[dp.length-1]=1;										
	
	//dp的生成---起到暴力递归方法作用
	for(int index=str.length-1;index>=0;index--) {			//返回的0位置，所以反递归起点则是最后一位
		if(str[index]=='0') {								//遇见0字符，直接退出（10的情况是另外一种可能，也会递归进行）
			dp[index]=0;
		}
		if(str[index]=='1') {								//当遇见1字符时，判断两种可能性（1后是否还有元素：分别转换、合并转换---'1n'永远在字符之中）
			dp[index] = dp[index+1];      					//直接转换
			if((index+1)<str.length) {
				dp[index] += dp[index+2];					//二个位置一起转换
			}
		}else if(str[index]=='2') {								
			dp[index] = dp[index+1];    					//直接转换
			if(index+1<str.length && str[index+1]<='6' && str[index+1]>='0') {     //<=26有合并转换的可能性
				dp[index] += dp[index+2];
			}
		}else {
			dp[index] = dp[index+1];						//其他情况，就直接进行下一个（类似递归）
		}
	}
	return dp[0];											//只有最终位置退出
}