从暴力递归到动态规划的转换（推荐）

从暴力递归到动态规划

给一串数字，返回其能否转换成IP地址形式（IP地址的正确形式）。
如110.125.10.5

int P(i,p)
假设0...i-1都已经转成合法的IP段了，组成的IP段数是p个。
则有：

递归版本:
/**
* Created by YangGang on 2017/9/6.
*/
public class ConvertStringToIP {

public static int convertNum1(String str){
//IP地址包括的数字个数范围在4~12
if(str==null||str.length()<4||str.length()>12){
return 0;
}
char [] chars=str.toCharArray();
return process(chars,0,0);
}

public static int process(char [] chars,int i,int parts){
//终止条件，一个是遍历结束，另一个是划分大于4部分，而IP只有4部分排除
if(i>chars.length||parts>4){
return 0;
}
//终止条件：已经到了结尾，看看是否正好分成4部分，若正好分成4部分则成功，否则失败
if(i==chars.length){
return parts==4?1:0;
}
//如果把自己作为一个部分，合法的个数
int res=process(chars,i+1,parts+1);
//如果当前字符是0，只能够把当前自己作为一段，因为IP中不可能出现012这种情况
if(chars[i]=='0'){
return res;
}
//如果当前字符不是0，则有可能是当前字符和下一字符一起构成一个部分。
res+=process(chars,i+2,parts+1);
//当前字符不是0，和下两个字符一起构成一部分,注意IP一个段只能是0-255
if(i+2<chars.length){
int sum=(chars[i]-'0')*100+(chars[i+1]-'0')*10+(chars[i+2]-'0');
if(sum<255)
{
return res+process(chars,i+3,parts+1);
}
else {
return res;
}
}
else {
return res;
}
}
}


递归：

第一步：了解BaseCase(不需要依赖任何，自己就知道自己的值)

第二步: 建立上下文关系

第三步：找好递归出口（边界条件）

递归改写：

首先看process(char [] chars,int i,int parts)函数

如果i和parts确定了，返回值就确定了。

所以可以建立一个二维表：(i,parts---唯一的返回值)

自然要关注parts的取值,parts的空间可以开成6个：0,1,2,3,4，>4(5) ;

i的取值[0,n+2]。

则二维表如下：

   0 1 2 3 4 5

0

1

2

.

.

.

n-1

n

n+1

n+2

(0,0)可能依赖(1,1)、(2,1)、（3,1）



先确定最右边的值，之后就从右边往左来。

然后从BaseCase转化，先填写好。



填写好后，再按照递归指示顺序把表剩余部分填写完毕。

从下往上，从右往左填写。



实际上并不需要都去填写。



看看哪些位置是不用算的，在for循环中控制一下，可以进一步减少计算。

改写成的DP代码如下：

public static int convertNum2(String str){
if(str==null||str.length()<4||str.length()>12){
return 0;
}
char [] chars=str.toCharArray();
int size=chars.length;
int [][]dp=new int [size+3][5];
//初始值
dp[size][4]=1;
for(int parts=3;parts>=0;parts--){
//因为IP每个段最多3位（i=Math.min(size-1,parts*3)）
for(int i=Math.min(size-1,parts*3);i>=parts;i=Math.min(i-1,parts*3)){
dp[i][parts]=dp[i+1][parts+1];
if(chars[i]!=0){
dp[i][parts]+=dp[i+2][parts+1];
if(i+2<chars.length){
int sum=(chars[i]-'0')*100+(chars[i+1]-'0')*10+(chars[i+2]-'0');
if(sum<256){
dp[i][parts]+=dp[i+3][parts+1];
}
}
}
}
}
return dp[0][0];
}

先算第3列，再算第2列，然后算第1列，最后算第0列。

刨除那些不需要算的，



因为p是有限的，所以可以蜕化为O(n)

所以把递归转换成动态规划的步骤是：

第一步：确定解空间

第二步：看看哪些事都不依赖的（BaseCase）设好值

第三步：看看哪个状态是所求的状态

最后一步：确定计算顺序

具体到dp的决策，把递归中的决策抄下来就行了。