动态规划（二）

一、矩阵的最小路径和

给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param matrix int整型二维数组 the matrix
     * @return int整型
     */
    public int minPathSum (int[][] matrix) {
        // write code here
        // dp[i][j]表示走到（i，j）位置时的最小路径和
        // dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + matrix[i][j]
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] dp = new int[n][m];
        dp[0][0] = matrix[0][0];
        for (int i = 1; i < m; i++) {
            dp[0][i] = dp[0][i - 1] + matrix[0][i];
        }
        for (int i = 1; i < n; i++) {
            dp[i][0] = dp[i - 1][0] + matrix[i][0];
        }
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < m; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + matrix[i][j];
            }
        }
        return dp[n - 1][m - 1];
    }
}

运行结果

二、把数字翻译成字符串

有一种将字母编码成数字的方式：'a'->1, 'b->2', ... , 'z->26'。

现在给一串数字，返回有多少种可能的译码结果

数据范围：字符串长度满足 0<n≤90

进阶：空间复杂度 O(n)，时间复杂度 O(n)

import java.util.*;


public class Solution {
    public int solve(String nums) {
        int dp0 = 1, dp1 = 1, pre = 3;
        for (char c : nums.toCharArray()) {
            // 一位数
            int num1 = c - '0';
            // 两位数
            int num2 = num1 + pre * 10;
            int next = 0;
            if (num2 >= 10 && num2 <= 26) {
                next += dp0;
            }
            if (num1 >= 1 && num1 <= 9) {
                next += dp1;
            }
            dp0 = dp1;
            dp1 = next;
            pre = c - '0';
        }
        return dp1;
    }
}

运行结果

三、兑换零钱

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

如果无解，请返回-1.

数据范围：数组大小满足 0≤n≤100000 ， 数组中每个数字都满足 0<val≤10000，0≤aim≤5000

要求：时间复杂度 O(n×aim)，空间复杂度 O(aim)。

import java.util.*;

public class Solution {
    public int minMoney (int[] arr, int aim) {
        int[] dp = new int[aim +
                           1]; // dp数组记录每一个目标金额，对应的最小找零数
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;

        for (int i = 1; i <= aim; i++) {
            for (int money : arr) {
                if (i >= money && dp[i - money] != Integer.MAX_VALUE) {
                    dp[i] = Math.min(dp[i - money] + 1, dp[i]);
                }
            }
        }

        return dp[aim] == Integer.MAX_VALUE ? -1 : dp[aim];
    }
}

运行结果

四、最长上升子序列

给定一个长度为 n 的数组 arr，求它的最长严格上升子序列的长度。

所谓子序列，指一个数组删掉一些数（也可以不删）之后，形成的新数组。例如 [1,5,3,7,3] 数组，其子序列有：[1,3,3]、[7] 等。但 [1,6]、[1,3,5] 则不是它的子序列。

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 给定数组的最长严格上升子序列的长度。
     * @param arr int整型一维数组 给定的数组
     * @return int整型
     */
    public int LIS (int[] arr) {
        int n = arr.length;
        if (n == 0) {
            return 0;
        }
        int[] dp = new int[n + 1];
        int res = 1;

        for (int i = 1; i <= n; i++) {
            dp[i] = 1;
            for (int j = i - 1; j > 0; j--) {
                if (arr[i - 1] > arr[j - 1]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

运行结果

五、连续子数组的最大和

输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，子数组最小长度为1。求所有子数组的和的最大值。

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param array int整型一维数组
     * @return int整型
     */
    public int FindGreatestSumOfSubArray (int[] array) {
        // write code here
        int n = array.length;
        int sum = -101;
        int tmp = 0;
        for (int i = 0; i < n; i++) {
            tmp += array[i];
            if (tmp < array[i]) {
                tmp = array[i];
            }
            sum = Math.max(sum, tmp);
        }
        return sum;
    }
}

运行结果

六、最长回文子串

对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param A string字符串
     * @return int整型
     */
    public int getLongestPalindrome (String A) {
        // write code here
        int n = A.length();
        int res = 1;
        for (int i = 0; i < n; i++) {
            int left = i;
            int right = i;
            while (left >= 0 && right < n) {
                if (A.charAt(left) == A.charAt(right)) {
                    res = Math.max(right - left + 1, res);
                    left--;
                    right++;
                } else {
                    break;
                }
            }
            left = i;
            right = i + 1;
            while (left >= 0 && right < n) {
                if (A.charAt(left) == A.charAt(right)) {
                    res = Math.max(right - left + 1, res);
                    left--;
                    right++;
                } else {
                    break;
                }
            }
        }
        return res;
    }
}

运行结果