动态规划小结

动态规划算法一般遵循一套固定的流程：递归的暴力解法 -> 带备忘录的递归解法 -> 非递归的动态规划解法。

package dynamic_programming;

/**
 * @program: Aglorithm
 * @Date: today
 * @Author: Kyrie
 * @Description:
 *
 * 动态规划小结
 */
public class Dynamic_Programming_Summary {
}

• 零钱兑换
  给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

	 // 暴力递归
    public static int coinsChange(int[] arr, int amount){
        //递归终止条件
        if (amount == 0) return 0;
        if (amount < 0) return -1;

        //初始化最小值min
        int min = Integer.MAX_VALUE; //判断最小值是否更新，若没有更新则说明不能凑成amount
        for (int i = 0; i < arr.length; i++) {
            if (amount - arr[i] < 0) continue;
            int coins = coinsChange(arr, amount - arr[i]);
            if (coins == -1) continue;
            min = Math.min(coins + 1, min);
        }
        return min == Integer.MAX_VALUE ?  -1 : min;
    }
    //备忘录方式
    public static HashMap<Integer, Integer> map = new HashMap<>(); //相当于备忘录的功能
    public static int coinsReplace02(int[] arr, int target){
        //递归终止条件
        if(target == 0)
            return 0;
        if (target < 0)
            return -1;
        if (map.containsKey(target))
            return map.get(target);   //相当于备忘录的功能

        int min = Integer.MAX_VALUE;
        for (int i = 0; i < arr.length; i++) {
            int diff = target - arr[i];
            int count = coinsReplace02(arr, diff);  //min
            if (count == -1)     //使用该硬币不能构成target
                continue;        //跳过该硬币
            //更新min
            int num = 1 + count; //使用该硬币   num代表使用的coins数量
            if (num < min){
                min = num;
                map.put(target, min);
            }
        }
        if (min == Integer.MAX_VALUE){  // 不能凑成
            return -1;
        }else
            return min;
    }

	//动态规划
    public int coinChange(int[] arr, int target) {
        if (target < 0 || arr.length == 0)
            return -1;
        int[] dp = new int[target + 1];

        for (int i = 1; i <= target; i++) {
            int min = Integer.MAX_VALUE;
            //int diff = -1;
            for (int j = 0; j < arr.length; j++) {
                int diff = i - arr[j];
                if (diff >= 0 && dp[diff] != -1)
                    min = Math.min(min, dp[diff]);
                //dp[i] = min == Integer.MAX_VALUE ? -1 : min + 1;  //若min为Integer.MAX_VALUE，则说明花掉的硬币，不能凑成总金额
            }
            dp[i] = min == Integer.MAX_VALUE ? -1 : min + 1;  //若min为Integer.MAX_VALUE，则说明花掉的硬币，不能凑成总金额
        }
        return dp[target];
        
    }

执行用时 : 21 ms, 在Coin Change的Java提交中击败了91.32% 的用户
内存消耗 : 35.1 MB, 在Coin Change的Java提交中击败了98.57% 的用户

• 最小路径和

package dynamic_processing;

public class Demo_dp02 {
    /**
     * @Author Kyrie
     * @Description
     * @Date today
     * 最小路径和：
     * 给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，
     * 使得路径上的数字总和为最小。每次只能向下或者向右移动一步。
     **/

    //递归方式
    public int minPathSum02(int[][] grid) {
        return process(grid, 0, 0);
    }
    public int process(int[][] arr, int i, int j) {

        if (i == arr.length - 1 && j == arr[0].length - 1)
            return arr[i][j];
        if (i == arr.length - 1)
            return arr[i][j] + process(arr, i, j + 1);
        if (j == arr[0].length - 1)
            return arr[i][j] + process(arr, i + 1, j);

        int right = process(arr, i, j + 1);
        int down = process(arr, i + 1, j);
        return arr[i][j] + Math.min(right, down);
    }
    //备忘录-方式  可以模仿使用HashMap来存储未计算的值，并判断是否该值已经存在


    //动态规划
    public static int minPathSum(int[][] arr) {
        if (arr == null || arr.length == 0 || arr[0] == null || arr[0].length == 0) {
            return 0;
        }

        int row = arr.length;
        int col = arr[0].length;
        int[][] dp = new int[row][col];
        dp[row - 1][col - 1] = arr[row - 1][col - 1];

        for (int j = col - 2; j >= 0; j--) {
            dp[row - 1][j] = dp[row - 1][j + 1] + arr[row - 1][j];
        }
        for (int i = row - 2; i >= 0; i--) {
            dp[i][col - 1] = dp[i + 1][col - 1] + arr[i][col - 1];
        }
        for (int i = row - 2; i >= 0; i--) {
            for (int j = col - 2; j >= 0; j--) {
                dp[i][j] = arr[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);
            }
        }
        return dp[0][0];
    }
    //进一步优化，使用空间复杂度为O(N)
}

• 最长相同子字符串

package dynamic_processing;

public class Demo_dp03 {
    /**
     * 最长相同子字符串
     * 输入
     * String X = "ATCTGAT";
     * String Y = "TGCATA";
     * 输出
     * String Z = "TCTA";  //4
     * <p>
     * 分析：最长相同子字符串可通过小一些的最长相同子字符串获得。
     * 尾部的字符，两种情况：1.X最后没有字母T，此时尾部字母相同；
     * 2.Y最后没有字母A，此时尾部字母相同；
     * 若计算出上述两个最长相同子字符串的答案，则其中较长的相同子字符串为X和Y的
     * 最长相同子字符串。
     * <p>
     * 对于两字符串的字尾相同时，可通过短一些的最长相同子字符串获取，之后在尾部加上
     * 共同拥有的字母。
     * <p>
     * 利用数学式子描述大问题的最优解和小问题的最优解的关系：
     * c[i,j]代表并存储其相关小问题的最优解的长度，即c[i,j]代表字串X中前面i个字符和
     * 字符串Y中前面的j个字符所形成的最长相同子字符串的长度。
     * 			0, if i = 0 or j = 0
     * c[i,j] = c[i-1][j-1] + 1, if i,j > 0 and Xi = Yj,
     * 			max(c[i-1][j], c[i][j-1]), if i,j > 0 and Xi != Yj
     */
    public static int findlongString(String str1, String str2) {

        if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0)
            return 0;
        int row = str1.length();
        int col = str2.length();
        int[][] dp = new int[row + 1][col + 1]; // 增加一行和一列省去初始化边界,初始化为0

        for (int i = 1; i <= row; i++) {
            for (int j = 1; j <= col; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1))  //当字符相等时
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else {
                    if (dp[i][j - 1] >= dp[i - 1][j])
                        dp[i][j] = dp[i][j - 1];
                    else
                        dp[i][j] = dp[i - 1][j];
                }
            }
        }
        //打印dp
        /*
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[0].length; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }*/
        return dp[row][col];
    }

    public static void main(String[] args) {
        String X = "ATCTGAT";
        String Y = "TGCATA";
        System.out.println(findlongString(X, Y));  // 4 
    }
}

• 安排员工聚会问题

package dynamic_processing;

public class Demo_dp04 {
    /**
     * @Author Kyrie
     * @Description
     * @Date today
     * @Param 员工数N， happy数组
     *      happyp[v] 每一个节点v将其快乐指数存于happy[v]中。
     *      sumofhappy[v] 以v为根的部门(小树)的最大快乐指数
     *      children[v,j] 若children[v,j]返回true，则代表节点v为j的父节点
     * @return 返回最大happy值
     *
     * 最优子结构判断：
     *      检查大问题的最优解可以利用小问题的最优解组合得到
     * 注意：
     *      若在公司找出N位员工是大问题，则小问题应该是什么？怎样的小问题的最优解对解大问题有帮助？
     *      比如，已知N-1位员工的小问题的最优解，好像对找到N位员工大问题的解帮助不大。因为，没有考虑数据结构之间的关系。
     *      原数据的数据结构是一颗树tree，因此小问题应该是小树或子树！！
     *
     * 最优子结构分析：
     *       1.若根节点考虑，则最大值依赖于其所有子节点的最大值之和
     *       2.若根节点不考虑，则最大值依赖于其所有孙节点的最大值之和
     *
     * 描述大问题与子问题之间的数学式子：
     *       若以v为根的部门的最大值存储于sumofhappy(v)中。当v是叶节点时，sumofhappy(v) = happy(v)。
     *       当v不是叶节点时，假设其子节点为ci，其孙节点为sj。可用下列式子描述大问题与子问题之间的数学关系：
     *       sumofhappy(v) = Max{sumofhappy(c1)+...+sumofhappy(ci); happy(v)+sumofhappy(s1)+...+sumofhappy(sj)};
     *       即：sumofhappy(v) = Max{};
     **/

}

• 单词拆分
  给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

  说明：拆分时可以重复使用字典中的单词。你可以假设字典中没有重复的单词。

  • 示例 1：

    输入: s = “leetcode”, wordDict = [“leet”, “code”]
    输出: true
    解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。

  • 示例 2：

    输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
    输出: true
    解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
    注意你可以重复使用字典中的单词。

  • 示例 3：

    输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
    输出: false

class Solution {
    //动态规划
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordDictSet = new HashSet(wordDict);   //构造一个包含指定 collection 中的元素的新set
        boolean[] dp = new boolean[s.length() + 1];  // 初始化均为false
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {  // 字符串的状态
            for (int j = 0; j < i; j++) {        // 从start开始到end之间，形成的字符串是否存在于字典中，start++, end不变
                if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        /*
        for (boolean b : dp)
            System.out.print(b + " "); //true false false false true false false false true 
        */
        return dp[s.length()];
    }
}

• 最长回文子串

package dynamic_processing;

public class Demo_dp06 {
    /**
     * 最长回文子串(动态规划版)
     * 给定一个字符串s，找到s中最长的回文子串。你可以假设s的最大长度为 1000。
     *
     * 示例 1：
     * 输入: "babad"
     * 输出: "bab"
     * 注意: "aba" 也是一个有效答案。
     *
     * 示例 2：
     * 输入: "cbbd"
     * 输出: "bb"
     * 暴力法将选出所有子字符串可能的开始和结束位置，并检验它是不是回文。
     * 动态规划就是优化暴力法的手段：首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…
     *
     */
    public static String longestPalindrome(String s) {
        int len = s.length();
        if(len == 0){
            return "";
        }
        char[] sToArray = s.toCharArray();
        boolean[][] mem = new boolean[len][len];
        int maxLen = 1;
        int fromIndex = 0;
        int toIndex = 1;
        // 初始化条件
        for(int i = 0; i < len; ++i){
            mem[i][i] = true;
            if(i + 1 < len && sToArray[i] == sToArray[i + 1]){
                mem[i][i + 1] = true;
                maxLen = 2;
                fromIndex = i;
                toIndex = i + 1 + 1;
            }
        }
        // 执行dp
        for(int i = 2; i < len; ++i){
            for(int j = 0; j < i - 1; ++j){
                mem[j][i] = mem[j + 1][i - 1] && sToArray[j] == sToArray[i];
                if(mem[j][i] && i - j + 1 > maxLen){
                    maxLen = i - j + 1;
                    fromIndex = j;
                    toIndex = i + 1;
                }
            }
        }

        return s.substring(fromIndex, toIndex);
    }

}