剑指 offer——贪心动态规划篇

Posted yzihan

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了剑指 offer——贪心动态规划篇相关的知识,希望对你有一定的参考价值。

10-I. 斐波拉契数列

题意:面试题10- I. 斐波那契数列
思路:最基础的动态规划题。数据量比较大的时候不能使用递归,会报StackOverFlow Exception,最优的方式是迭代计算。

class Solution {
    public int fib(int n) {
        if (n <= 1) {
            return n;
        }
        int a = 0;
        int b = 1;
        int index = 2;
        int tmp;
        while (index <= n) {
            tmp = (a + b) % 1000000007;
            a = b;
            b = tmp;
            index ++;
        }
        return b;
    }
}

10-II. 青蛙跳台阶

题意:面试题10- II. 青蛙跳台阶问题

思路:同斐波拉契数列问题,最基础的动态规划问题。

class Solution {
    public int numWays(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        int a = 1;
        int b = 1;
        int c = 0;
        int i = 2;
        while (i <= n) {
            c = (a + b) % 1000000007;
            a = b;
            b = c;
            i++;
        }
        return c;
    }
}

14-I. 剪绳子

题意:面试题14- I. 剪绳子
思路1:dp[i]表示长度为i的绳子,能够得到的最大乘积数。dp[i+1]的计算方式为,每次可以剪掉1~i的长度j,其余的绳子可以剪(即dp[i+1-j]),也可以不剪(即i+1-j),即
dp[i+1] = Math.max(dp[i+1-j] * j, (i+1-j) * j), 其中j (in) [1, i]

class Solution {
    public int cuttingRope(int n) {
        if (n == 2) {
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[2] = 1;
        for (int i = 3; i < n + 1; i ++) {
            for (int j = 1; j < i;j ++) {
                dp[i] = Math.max(dp[i-j] * j, (i-j)*j);
            }
        }
        return dp[n];
    }
}

思路2:将绳子长度先尽可能的划分为3的倍数,如果最后剩余1,则拿出一个已经分配的3来凑成4。
例如:5 = 3 + 2
6 = 3 + 3 -> 3 * 3 = 9
7 = 3 + 3 + 1 = 3 + 4 -> 3 * 4 = 12
……

class Solution {
    public int cuttingRope(int n) {
        if (n <= 3) {
            return n - 1;
        }
        int remind = n;
        int multi = 1;
        while (remind > 4) {
            multi = multi * 3;
            remind -= 3;
        }
        return multi * remind;
    }
}

14-II. 剪绳子 II

题意:试题14- II. 剪绳子 II
思路:同剪绳子I

class Solution {
    public int cuttingRope(int n) {
        if (n <= 3) {
            return n - 1;
        }
        int remind = n;
        long multi = 1;
        while (remind > 4) {
            multi = (multi * 3) % 1000000007;
            remind -= 3;
        }
        return (int)((multi * remind) % 1000000007);
    }
}

19. 正则表达式匹配

题意:面试题19. 正则表达式匹配
思路:用dp[i][j]表示s字符串前i个字符串是否与p的前j个字符串匹配,那么所要求的结果就是dp[s.length()][p.length()]的值。
递推式:对于某一个位置dp[i][j],是否匹配可以分以下两种情况:
(1)当s[i] == p[j]时,如果s[0...i-1]与p[0...j-1]匹配,那么s[0...i]与p[0...j]匹配,反之不匹配。即dp[i][j] = dp[i-1][j-1];
(2)当s[i] != p[j]时。如果p[j] != ‘*’,那么s[0...i]与p[0...j]一定不匹配。如果p[j] == ‘*‘,代表p[j-1]位置的字符可以出现0次或多次
(a)当p[j-1]位置的字符不出现时,判断s[0...i]与p[0...j-2]是否匹配即可,即dp[i][j] = dp[i][j-2]
(b)当p[j-1]位置的字符出现时,需要判断s[i]位置上的字符是否与p[j-1] (注意可以是‘.‘)相同,相同则dp[i][j] = dp[i-1][j]

class Solution {
    public boolean isMatch(String s, String p) {
        int sLen = s.length();
        int pLen = p.length();
        char[] sArr = s.toCharArray();
        char[] pArr = p.toCharArray();
        boolean[][] dp = new boolean[sLen + 1][pLen + 1];
        dp[0][0] = true;
        for (int i = 0; i < sLen + 1; i ++) {
            for (int j = 1; j < pLen + 1; j ++) {
                if (i > 0 && (sArr[i - 1] == pArr[j - 1] || pArr[j - 1] == ‘.‘)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else if (pArr[j - 1] == ‘*‘){
                    if (i > 0 && j > 1
                    && (sArr[i - 1] == pArr[j - 2] || pArr[j - 2] == ‘.‘)) {
                        dp[i][j] |= dp[i - 1][j];
                    }
                    if (j > 1){
                        dp[i][j] |= dp[i][j - 2];
                    }
                }
            }
        }
        return dp[sLen][pLen];
    }
}

42. 连续子数组的最大和

题意:面试题42. 连续子数组的最大和
思路:贪心。状态转移方程式为sum[i] = max(sum[i-1] + nums[i], nums[i]),其中sum[i]表示元素nums[0...i]的和。

class Solution {
    public int maxSubArray(int[] nums) {
        int max = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = 0; i < nums.length; i ++) {
            sum = Math.max(sum + nums[i], nums[i]);
            max = Math.max(max, sum);
        }
        return max;
    }
}

47. 礼物的最大价值

题意:面试题47. 礼物的最大价值
思路:动态规划。递推公式dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j],优化为一维后,第i行礼物最大价值:dp[j] = max(dp[j-1], dp[j]) + grid[i][j]。

class Solution {
    public int maxValue(int[][] grid) {
        int[] dp = new int[grid[0].length];
        dp[0] = grid[0][0];
        for (int j = 1; j < dp.length; j ++) {
            dp[j] = dp[j - 1] + grid[0][j];
        }
        for (int i = 1; i < grid.length; i ++) {
            for (int j = 0; j < grid[0].length; j ++) {
                if (j == 0) {
                    dp[j] += grid[i][j];
                } else {
                    dp[j] = Math.max(dp[j - 1], dp[j]) + grid[i][j];
                }
            }
        }
        return dp[grid[0].length - 1];
    }
}

49. 丑数

题意:面试题49. 丑数
思路:动态规划。丑数是2,3,5的倍数,下一个丑数一定是前面某一个数乘以2或3或5得到的最小数字。使用三个指针two、three、five分别指向2、3、5的倍数,下一个更大的数将由这三个指针指向的数字分别乘2、乘3、乘5取最小值得到。取得最小值之后指针向前走一步。

class Solution {
    public int nthUglyNumber(int n) {
        int two = 0;
        int three = 0;
        int five = 0;
        int[] dp = new int[n];
        dp[0] = 1;
        for (int i = 1; i < n; i ++) {
            dp[i] = Math.min(Math.min(dp[two] * 2, dp[three] * 3), dp[five] * 5);
            if (dp[i] == dp[two] * 2) {
                two ++;
            }
            if (dp[i] == dp[three] * 3) {
                three ++;
            }
            if (dp[i] == dp[five] * 5) {
                five ++;
            }
        }
        return dp[n - 1];
    }
}

60. n个骰子的点数

题意:面试题60. n个骰子的点数
思路:用freq[i][j]表示i个骰子,投出点数为j的次数。那么递推式为:
freq[i][j] = freq[i-1][j-1] + freq[i-1][j-2] + …… + freq[i-1][j-k](其中k<=6 且j-k>0,因为一个骰子只能投出1~6点)

class Solution {
    public double[] twoSum(int n) {
        int[][] freq = new int[n + 1][n * 6 + 1];
        for (int i = 1; i <= 6; i ++) {
            freq[1][i] = 1;
        }
        int k;
        for (int i = 2; i <= n; i ++) {
            for (int j = i; j <= n * 6; j ++) {
                k = 1;
                while (k <= 6 && j - k > 0) {
                    freq[i][j] += freq[i-1][j - k];
                    k ++;
                }
            }
        }
        double sum = Math.pow(6, n);
        double[] res = new double[5 * n + 1];
        for (int i = 0; i < res.length; i ++) {
            res[i] = freq[n][n + i] / sum;
        }
        return res;
    }
}

63. 股票的最大利润

题意:面试题63. 股票的最大利润
思路:动态规划。遍历数组的过程中,记录数组中最小的数字作为股票买入的价格。当前遍历到的数字减去最小的数字就是最大的利润。

class Solution {
    public int maxProfit(int[] prices) {
        int max = 0;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < prices.length; i ++) {
            min = Math.min(min, prices[i]);
            max = Math.max(max, prices[i] - min);
        }
        return max;
    }
}






















以上是关于剑指 offer——贪心动态规划篇的主要内容,如果未能解决你的问题,请参考以下文章

剑指offer-动态规划-贪心算法--剪绳子-python

剑指 Offer 14- I. 剪绳子(C++暴力+动态规划贪心解)

剑指offer——第二十九天(动态规划“困难”)

leetcode刷题总目录

写写代码系列013:剑指offer题目——连续子数组的最大和(动态规划)

剑指Offer - 动态规划