Leet专题刷题Day06-动态规划01

Leet专题刷题Day06-动态规划01

1838. 最高频元素的频数

class Solution {
    public int maxFrequency(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length;
        // 初始化滑动窗口
        int l = 0, r = 1;
        // 无论如何，答案至少为 1，初始化 ans = 1
        int ans = 1;
        while (r < n) {
            // 右边界右移一步，新添加的面积要用 k 来弥补
            k -= (nums[r] - nums[r - 1]) * (r - l);
            if (k >= 0) {
                // 答案
                ans = Math.max(ans, r - l + 1);
            } else {
                // 左边界右移一步，减少的面积可以补充 k 的值
                k += nums[r] - nums[l++];
            }
            // 滑动窗口的 r 一直在向右边移动
            r++;
        }
        return ans;
    }
}

剑指 Offer 42. 连续子数组的最大和

用dp数组记录从头开始当前位置的连续子数组最大和。

如果前一个是负数，就没有贡献，用当前数据，有贡献就用

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0] ;
        int ans = dp[0];
        for (int i = 1; i < n; i++){
            if (dp[i-1]> 0){
                dp[i] = dp[i-1] + nums[i];
            }else{
                dp[i] = nums[i];
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;

    }
}

70. 爬楼梯

第n层的楼梯是n-1和n-2的楼梯数量之和。

因为一次可以爬一个或两个台阶。

n-2爬两个台阶的可能加上n-1爬一个台阶。

class Solution {
    public int climbStairs(int n) {
        if (n <= 2) return n;
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n-1];

    }
}

121. 买卖股票的最佳时机

只需要记录当前位置最小的买入股票的价格就好了

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

剑指 Offer 10- I. 斐波那契数列

class Solution {
    public int fib(int n) {
        int a = 0, b = 1, sum;
        for(int i = 0; i < n; i++){
            sum = (a + b) % 1000000007;
            a = b;
            b = sum;
        }
        return a;
    }
}

118. 杨辉三角

思路一：排列组合 每一排都是C m n 从0到m, 计算超出long

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> res = new ArrayList<>(); 
        for (int i = 0; i < numRows; i++){
            res.add(c(i));
        }
        return res;
    }
    List<Integer> c(int n){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i <= n; i++){
            long candidate = A(i, n) / A(i,i);
            list.add((int)candidate);
        }
        return list;
    }

    long A(int n1, int n2) {
        int ans = n2;
        n2--;
        for (int i = 1; i < n1; i++){
            ans = ans * n2;
            n2--;
        }
        return n1 == 0 ? 1 : ans;
    }
}

思路二：dp

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        int[][] dp = new int[numRows][numRows];
        dp[0][0] = 1;
        result.add(new ArrayList<Integer>(){{ add(dp[0][0]);}});
        if (numRows == 1) {
            return result;
        }

        for (int i = 1; i < numRows; i++) {
            List<Integer> num = new ArrayList<>();
            dp[i][0] = 1;
            num.add(dp[i][0]);
            for (int j = 1; j < i; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                num.add(dp[i][j]);
            }
            dp[i][i] = 1;
            num.add(dp[i][i]);
            result.add(num);
        }
        return result;
    }
}