Java——从递归到动态规划（Leecode343/198）

class Solution {
    public int integerBreak(int n) {
        if(n<2) return -1;
        return HelperInteger(n);
    }
    public int HelperInteger(int n){
        if(n==2||n==1) return 1;
        int max = 0;
        for(int i = 1;i<n;i++){
            max=max(max,i*(n-i),i*HelperInteger(n-i)) ;
        }
        return max;
    }
    public int max(int a,int b,int c){
        return Math.max(a,Math.max(b,c));
    }
}

class Solution {
    public int integerBreak(int n) {
       int memory[] = new int[n+1];
        for (int i = 0;i<n;i++){
            memory[i] = -1;
        }
        memory[1] =1;
        //求解memory i
        for(int i=2;i<=n;i++){
            //对i进行分割
            for(int j = 1;j<=i-1;j++){
                memory[i]=max(memory[i],j*(i-j),j*memory[i-j]);
            }
        }
        return memory[n];
    }
    public int max(int a,int b,int c){
       if (a > b) {
            if (a > c) {
                return a;
            } else {
                return c;
            }
        } else {
            if (b > c) {
                return b;
            } else {
                return c;
            }
        }
    }
}

    public int rob(int[] nums) {
        int n = nums.length;
        if(n==0) return 0;
        return HelpRob(nums,0);   
    }
   //递归
    public int HelpRob(int[] nums, int index){
        if(index>=nums.length) return 0;
        int res = -1;
        for(int i = index;i<nums.length;i++){
            res = Math.max(res,nums[i]+HelpRob(nums,i+2));
        }
        return res;
    }

class Solution {
    int robmax[] ;
    public int rob(int[] nums) {
        int n = nums.length;
        if(n==0) return 0;
        //robmax为考虑从i到n-1的房子中所能获得的最大价值
        robmax = new int[n];
        for(int i = 0;i<n;i++){
            robmax[i] = -1;
        }
       return HelpRob(nums,0);  
    }
 //记忆化搜索
    public int HelpRob(int[] nums, int index){
        if(index>=nums.length) return 0;
        if(robmax[index]!=-1)
            return robmax[index];
        int res = -1;
        for(int i = index;i<nums.length;i++){
            res = Math.max(res,nums[i]+HelpRob(nums,i+2));
        }
        robmax[index] = res;
        return res;
    }
    }

class Solution {
    int robmax[] ;
    public int rob(int[] nums) {
        int n = nums.length;
        if(n==0) return 0;
        //robmaxi为考虑从i到n-1的房子中所能获得的最大价值
        robmax = new int[n];
        for(int i = 0;i<n;i++){
            robmax[i] = -1;
        }
        robmax[n-1]=nums[n-1];
        //计算从i到n-1的最大价值,而最小问题是只偷最后一个房子，所以从后向前遍历
        for(int i = n-2;i>=0;i--){
            for(int j=i;j<n;j++){
            //要保证j+2不超过数组边界，不超过取值，超过了则+0即可。
                robmax[i] = Math.max(robmax[i],nums[j]+(j+2<n?robmax[j+2]:0) );
            }
        }
        return robmax[0];
    }
}