递归和动态规划专题（二）----剑指offer+左程云算法

递归和动态规划专题（二）—-剑指offer+左程云算法

---

【前言】1.动态规划算法是从暴力搜索算法优化过来的，如果我们不清楚暴力搜索的过程，就难以理解动态规划的实现，当我们了解了动态规划算法的基本原理的文字概述，实现条件之后，这时可能并不是太理解这种思想，去面对实际问题的时候也是无从下手，这个时候我们不能停留在文字层面上，而应该去学习经典动态规划算法的实现，然后倒回来看这些概念，便会恍然大悟。

　　2.动态规划算法的难点在于 从实际问题中抽象出动态规划表dp，dp一般是一个数组，可能是一维的也可能是二维的，也可能是其他的数据结构。

　３.总体来说，动态规划算法就是一系列以空间换取时间的算法。

---

（一）.矩阵的最小路径和

【题目】给定一个矩阵m，从左上角开始每次只能向右走或者向下走，最后达到右下角的位置，路径中所有数字累加起来就是路径和，返回所有路径的最小路径和，如果给定的m如下，那么路径1,3,1,0,6,1,0就是最小路径和，返回12.
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0

这是经典的动态规划问题：假设m是m行n列的矩阵，那么我们用dp[m][n]来抽象这个问题，dp[i][j]表示的是从原点到i,j位置的最短路径和。我们首先计算第一行和第一列，直接累加即可，那么对于其他位置，要么是从它左边的位置达到，要么是从上边的位置达到，我们取左边和上边的较小值，然后加上当前的路径值，就是达到当前点的最短路径。也就是说问题分为三种情况：第一行dp[0][j] 第一列 dp[i][0] 和非第一行第一列dp[i][j]. dp矩阵称为动态规划表！

import java.util.*;
public int minPathSum1(int[][] m){
    if(m==null||m.length==0||m[0]==null||m[0].length==null){
        return 0;
    }
    rows=m.length;
    cols=m[0].length;
    int[][] dp=new int[rows][cols];
    dp[0][0]=m[0][0];
    //第一行都是前面的累加
    for(int j=1;j<cols;j++){
        dp[0][j] = dp[0][j-1]+m[0][j];
    }
    //第一列都是上面的累加
    for(int i=1;i<cols;i++){
        dp[i][0] = dp[i-1][0]+m[i][0];
    }
    //构建动态规划表dp
    for(int i=2;i<cols;i++){
        for(int j=2;j<cols;j++){

            dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+m[i][j];
        }
    }
    return dp[rows-1][cols-1];
}

该方法时间复杂度为O(N*M),空间复杂度由于新建了动态规划表dp,所以为O(N*M)！但是动态规划可以通过空间压缩的方法将额外空间复杂度变成O(min{M,N}),也就是不使用M*N的dp矩阵，而是使用arr[]一维数组。

import java.util.*;
public int minPathSum1(int[][] m){
    if(m==null||m.length==0||m[0]==null||m[0].length==null){
        return 0;
    }
    int more = Math.max(m.length,m[0].length);//行数和列数较多的那个
    int less = Math.min(m.length,m[0].length);//行数和列数较少的那个

    int[] arr= new int[less];
    boolean rowMore = m.length==more;//判断是行数多还是列数多
    arr[0]==m[0][0];
    //让第一行或第一列赋值给arr数组
    for(int i=1;i<less;i++){
        arr[i]=arr[i-1]+(rowMore ? m[0][i]:m[i][0]);
    }

    //arr数组往下滚 从arr[0]开始逐渐得到该行的最短路径；
    for(int i=1;i<more;i++){
        arr[0]=arr[0]+(rowMore ? m[i][0]:m[0][i]);
        for(int j=1;j<less;j++){
            arr[j] = Math.min(arr[j-1],arr[j])+(rowMore?m[i][j]:m[j][i]);
        }
    }

    return arr[less-1];

}

---

（二）.换钱的方法

【题目】给定数组arr，arr中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim代表要找的钱数，求换钱有多少种方法。

【举例】

arr=[5,10,25,1]，aim=0。组成0元的方法有1种，就是所有面值的货币都不用。所以返回1。

arr=[5,10,25,1]，aim=15。组成15元的方法有6种，分别为3张5元，1张10元+1张5元，1张10元+5张1元，10张1元+1张5元，2张5元+5张1元，15张1元。所以返回6。

arr=[3,5]，aim=2。任何方法都无法组成2元。所以返回0。

这个题目讲的是从暴力递归到动态规划：
递归 –> 记忆化搜索（备忘录方法）– dp –> dp状态合并！在这里直接给出动态规划基础方法及动态规划的优化方法！

【分析】生成行数为N，列数为aim+1的动态规划表矩阵dp，dp[i][j]的含义表示使用arr[0…i]种货币组成要找的数j有多少种？

1. 对于矩阵dp第一列 ，dp[0….i][0]表示组成要找的数为0，很明显是1种即为不使用任何货币！
2. 对与矩阵dp第一行，dp[0][0……aim]表示组成的数为0…aim,很明显dp[0][k*arr[0]]==1(0<=arr[0]*k<=aim)!
3. 对于矩阵dp上非第一行第一列的数，即为位置（i ，j）。dp[i][j]有以下多种情况：

1.完全不用arr[i],用arr[0….i-1]货币组成j;
2.用一张arr[i],用arr[0….i-1]货币组成j-arr[i];
………
k+1.用k张arr[i],用arr[0….i-1]货币组成j-k*arr[i] (j-k*arr[i]>=0);

【注意】通过分析我们可以发现上述的第三种情况可以简化为dp[i][j] = dp[i-1][j]+dp[i][j-arr[i]];最终代码如下，时间复杂度为O（N*aim），空间复杂度为O（N*aim）；

import java.util.*;

public class Exchange {
    public int countWays(int[] penny, int n, int aim) {


    if(penny==null||penny.length==0||aim==0){
        return 0;
    }
    int[][] dp=new int[penny.length][aim+1];
    //第一列，均为0;
    for(int i=0;i<penny.length;i++){
        dp[i][0]=1;
    }
    //第一行，k*arr[0]为0;
    for(int j=0;j*penny[0]<aim+1;j++){
        dp[0][j*penny[0]]=1;
    }
    for(int i=1;i<penny.length;i++){
        for(int j=1;j<aim+1;j++){

            dp[i][j]=dp[i-1][j];
            dp[i][j]+=j-penny[i]>=0?dp[i][j-penny[i]]:0;


        }
    }
    return dp[penny.length-1][aim];

    }
}

【注意】通过动态规划的空间压缩，把dp矩阵用dp一维矩阵表示,滚下一行！使额外空间复杂度变为O（aim）方法。

import java.util.*;

public class Exchange {
    public int countWays(int[] penny, int n, int aim) {


    if(penny==null||penny.length==0||aim==0){
        return 0;
    }

    int[] dp=new int[aim+1];

    for(int i=0;i*penny[0]<=aim;i++){
        dp[i*dp[0]]=1;
    }

    for(int i=1;i<n;i++){
        for(int j=1;j<=aim;j++){

            dp[j]+=j-penny[i]>=0?dp[j-penny[i]]:0;
        }
    }

    return dp[aim];
    }
}

---

(三).记录几道《剑指offer》中与连续子序列（连续子数组）有关的题目！

【题目】HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        //记住：整数最大值为：2^31-1 0x7FFFFFFF   最小值：-2^31  0x80000000

        if(array==null||array.length==0){
            return 0;
        }
        int sum=0;
        int greatSum=0x80000000;
        for(int i=0;i<array.length;i++){
            //如果sum小于0，把之前累加的都去除
            if(sum<=0){
                sum=array[i];
            }else{
                sum+=array[i];

            }

            if(sum>greatSum){
                    greatSum = sum;
            }
        }

        return greatSum;             

    }
}

【题目】小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列?
Good Luck!

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
       //和为S的连续正数序列；

        ArrayList<ArrayList<Integer> > arrayList = new ArrayList<ArrayList<Integer> > ();
        if(sum<3){
            return arrayList;
        }
        int small=1;
        int big=2;
        int middle = (1+sum)/2;
        int s=small+big;
        //至少包括俩个数，所以由此可以把small<middle作为循环判断条件
        while(small<middle){
            if(s==sum){
                arrayList.add(Sequence(small,big));
            }
            //当系列和大于sum以及small仍小于middle时；
            while(s>sum&&small<middle){
                s-=small;
                small++;
                if(s==sum){
                    arrayList.add(Sequence(small,big));
                }
            }

            big++;
            s+=big;

        }

        return arrayList;

    }

    public ArrayList<Integer> Sequence(int small,int big){

        ArrayList<Integer> list = new ArrayList<Integer>();
        if(small<big){
            for(int i=small;i<=big;i++){
                list.add(i);
            }
        }
        return list;

    }

}

【题目】输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        //因为递增排序，所以考虑从左右俩边开始往中间遍历；
        ArrayList<Integer> list= new ArrayList<Integer>();
        if(array==null||array.length<2){
            return list;
        }

        int i=0;
        int j=array.length-1;
        while(i<j){
            int s=array[i]+array[j];
            if(s>sum){
                j--;
            }else if(s<sum){
                i++;
            }else if(s==sum){
                list.add(array[i]);
                list.add(array[j]);
                return list;
            }
        }
        return list;
    }
}

---

(四).最长上升子序列问题（LIS）

【注意】为什么上面第三点要记录《剑指offer》里的子序列题目呢？因为我刷到这道题时发现思路和上面的几道题相似！然而非也，我错以为最长上升子序列为最长连续上升子序列，所以最优解仍然需要使用动态规划！

如果为最长连续上升子序列：

import java.util.*;

public class LongestIncreasingSubsequence {

    public int getLIS(int[] A, int n) {
        //记录上升子序列的长度
        int count=1;
        if(A==null||n==0){
            return 0;
        }

        int i=0;
        int greatNum=1;
        for(int j=0;j<n-1;j++){
            if(A[j]>=A[j+1]){
                count=1;
            }else{
                count++;
            }

            if(count>greatNum){
                greatNum=count;
            }

        }
        return greatNum;
    }
}

按照题意，使用动态规划的解法：

import java.util.*;

public class LongestIncreasingSubsequence {
   public int getLIS(int[] A, int n) {
        // write code here
        if (n <= 0)
            return -1;
        int[] dp = new int[n];
        dp[0] = 1;
        for (int i = 1; i < n; i++) {
            int j = i - 1;
            int max = 1;
            while (j >= 0) {
                if (A[i] > A[j]) {
                    if (dp[j] + 1 > max)
                        max = dp[j] + 1;
                }
                j--;
            }
            dp[i] = max;
        }
        int max = 1;
        for (int i = 0; i < dp.length; i++) {
            if (dp[i] > max)
                max = dp[i];
        }
        return max;

    }
}

****要回家啦，未完待续**