Letcode动态规划专题-初级

已于 2022-05-09 20:10:01 修改
阅读量647 收藏
点赞数
分类专栏： 剑指offer2022 文章标签： 编辑器 vscode macos
于 2022-05-02 16:43:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43170213/article/details/124542981
版权

最大子数组和

在这里插入图片描述
最大子数组的和

爬楼梯

在这里插入图片描述

杨辉三角《一》《2》

// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1
//

// f(i)(j) = f(i-1)f(j-1)+f(i)f(j-1)

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        int[][] array = new int[numRows][numRows];
        for(int i = 0;i<numRows;i++){
            List<Integer> list = new ArrayList<Integer>();
            for(int j = 0;j<=i;j++){
                if(j==0||j==i){
                    array[i][j]=1;
                }else{
                   array[i][j]=array[i-1][j-1]+array[i-1][j];
                }
                list.add(array[i][j]);
            }
            result.add(list);

        }
        return result;
    }
}

// 1
// 1 1
// 1 2 1 
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1 
//

//  f(i)(j) = f(i-1)f(j-1)+f(i)f(j-1)

2、121. 买卖股票的最佳时机

两个动态规划方程


// 动态规划 前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格}

class Solution {
    public int maxProfit(int[] prices) {
        int maxProfit =0;
        int minValue = Integer.MAX_VALUE;

        for(int price:prices){
            if(price<minValue){
                minValue = price;
            }else{
                maxProfit = Math.max(price-minValue,maxProfit);
            }
        }
        return maxProfit;
    }
}

状态定义方法：将第i天卖出股票可以获得的最大利润定义为dp[i]，然后求解，代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int res = 0;
        // 前一天卖出可以获得的最大利润
        int pre = 0;
        for (int i = 1; i < len; i++) {
            // 利润差
            int diff = prices[i] - prices[i - 1];
           // 状态转移方程：第i天卖出可以获得的最大利润 = 第i-1天卖出的最大利润 + 利润差
            pre = Math.max(pre + diff, 0);
            res = Math.max(res, pre);
        }
        return res;
    }
}

在这里插入图片描述

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        // 特殊判断
        if (len < 2) {
            return 0;
        }
        int[][] dp = new int[len][2];

        // dp[i][0] 下标为 i 这天结束的时候，不持股，手上拥有的现金数
        // dp[i][1] 下标为 i 这天结束的时候，持股，手上拥有的现金数

        // 初始化：不持股显然为 0，持股就需要减去第 1 天（下标为 0）的股价
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

        // 从第 2 天开始遍历
        for (int i = 1; i < len; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
        }
        return dp[len - 1][0];
    }
}

338. 比特位计数

在这里插入图片描述
1、常规的暴力破解方法

class Solution {
    public int[] countBits(int n) {
        int[] result = new int[n+1];
        for(int i=0;i<=n;i++){
            result[i] = countOnes(i);
        }
        return result;
    }

    public int countOnes(int x){
        int one= 0;
        while(x>0){
            x = x&(x-1);
            one++;
        }
        return one;
    }
}

在这里插入图片描述

2、状态转移方程

class Solution {
    public int[] countBits(int n) {
        int[] dp = new int[n+1];

        for(int i=0;i<=n;i++){
            if (i%2==0) {
                dp[i]=dp[i/2];
            } else {
                dp[i]=dp[i/2]+1;
            }
        }
        return dp;
    }
}

在这里插入图片描述

菲波那切数列-滚动数组

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

class Solution {
    public int fib(int n) {
        if(n<2){
            return n;
        }

        int p = 0;
        int q = 0;
        int r = 1;
        for(int i=2;i<=n;i++){
            p=q;
            q=r;
            r=p+q;
        }
        return r;


    }
}

花费最小的代码爬楼梯

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int size = cost.length;
        int[] dp = new int[size+1];
        dp[0] = 0;
        dp[1] = 0;
        for(int i=2;i<=size;i++){
            dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[size];
    }
}




//  首先要推递归方程
//  f(0) = 0 ; f(1) =0 
//  f(n) = Min(f(n-1)+cost[n-1],f(n-2)+cost[n-2])

第 N 个泰波那契数

泰波那契序列 Tn 定义如下：

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

class Solution {
    public int tribonacci(int n) {
        int[] dp = new int[n+1];
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        if(n==2){
            return 1;
        }
        dp[0] =0;
        dp[1] =1;
        dp[2] =1;
        for(int j=3;j<dp.length;j++){
            dp[j] = dp[j-1] + dp[j-2] + dp[j-3];
        }
        return dp[n];
    }
}

获取生成数组中的最大值

在这里插入图片描述

class Solution {
    public int getMaximumGenerated(int n) {
        int[] dp  = new int[n+1];
        
        if(n==0){
            return 0;
        }

        if(n==1){
            return 1;
        }

        int max = 1;
        dp[0]=0;
        dp[1]=1;
        for(int j=2;j<=n;j++){
            if(j%2==0){
                dp[j] =dp[j/2];
            }else{
                dp[j] = dp[j/2]+dp[j/2+1];
            }
            max = (dp[j]>max)?dp[j]:max;
        }
        return max;
    }
}

下载插件

在这里插入图片描述

令 dp[i] 表示下载 i 个插件需要的最少分钟数,则 dp[i] = dp[(i + 1) / 2] + 1;

在这里插入图片描述

剑指 Offer 10- II. 青蛙跳台阶问题

在这里插入图片描述

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

// 动态规划方程
// f(0)=0
// f(1)=1
// f(2)=2
// f(n)=f(n-1)+f(n-2)

连续子数组的最大和


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



// 连续子数组的最大和 
//      Max(f(i-1)+cost[i],cost[i])

面试题 08.01. 三步问题

在这里插入图片描述

class Solution {
    public int waysToStep(int n) {
        if(n==1){
            return 1;
        }

        if(n==2){
            return 2;
        }

        if(n==3){
            return 4;
        }

        int[] dp  = new int[n+1];
        dp[1]=1;
        dp[2]=2;
        dp[3]=4;
        for(int i=4;i<=n;i++){
            dp[i] = ((dp[i-1]+dp[i-2])%(1000000007)+dp[i-3])%(1000000007); 
        }
        return dp[n]%(1000000007);
    }
}
// 动态规划方程

// f(n)=f(n-1)+f(n-2)+f(n-3)

面试题 17.16. 按摩师

在这里插入图片描述

class Solution {
    public int massage(int[] nums) {
        int len = nums.length;
        if(len==0){
            return 0;
        }

        if(len==1){
            return nums[0];
        }

        // dp[i][0]:区间[0,i]里接收预约请求，并且下标为i的这一天不接受预约
        // dp[i][1]:区间[0,i]里接收预约请求，并且下标为i的这一天接收预约

        int[][] dp = new int[len][2];
        dp[0][0] =0;
        dp[0][1] = nums[0];

        for(int i=1;i<len;i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]);
            dp[i][1] = dp[i-1][0] + nums[i];
        }
        return Math.max(dp[len-1][0],dp[len-1][1]);
    }
}

翻转数位

在这里插入图片描述

class Solution {
    public int reverseBits(int num) {
        int[] current = new int[32];
        int[] reverse = new int[32];
        int max = 0;


        if((num&1)==1){
            current[0]=1;
            reverse[0]=1;
        }else{
            current[0]=0;
            reverse[0]=1;
        }
        num=num>>1;
        for(int i=1;i<32;i++){
            if((num&1)==1){
                current[i]=current[i-1]+1;
                reverse[i]=reverse[i-1]+1;
            }else{
                current[i]=0;
                reverse[i]=current[i-1]+1;
            }
            if(reverse[i]>max){
                max = reverse[i];
            }
            num=num>>1;
        }
        return max;
    }
}

// current[i] 表示包含第i位的从num二进制低位至第i位联系1的最长长度
// reverse[i] 表示包含第i位的从低位到第i位最多翻转1个0->1的连续1的最长长度
// 用num[i] 表示整数num第i位的值
// 遍历num所有位数，也就是32位，reverse数组中最大值就是答案
//  转态方程
//  current[i]= num[i]==1?current[i-1]+1:0；
//  reverse[i]= num[i]==1?reverse[i-1]+1:current[i-1]+1

除数博弈

在这里插入图片描述

在这里插入图片描述

class Solution {
    public boolean divisorGame(int n) {
        if(n==1){
            return false;
        }

        if(n==2){
            return true;
        }
        
        boolean[] flag = new boolean[n+1];

        flag[1] = false;
        flag[2] = true;

        for(int i=3;i<=n;i++){
            for(int j=1;j<i;j++){
                if((i%j==0)&&(!flag[i-j])){
                    flag[i] =true;
                    break;
                }
            }
        }
        return flag[n];
    }
}






// 爱丽丝先开局

判断子序列

1.双指针

class Solution {
    public boolean isSubsequence(String s, String t) {
        // s是子序列
        int m = s.length();
        // t是非子序列
        int n = t.length();
        int i = 0;
        int j = 0;

        while(i<m&&j<n){
            if(s.charAt(i)==t.charAt(j)){
                j++;
            }
            i++;
        }

        return j==m;

    }
}

2、动态规划方法
在这里插入图片描述
在这里插入图片描述

class Solution {
    public boolean isSubsequence(String s, String t) {
        int n = s.length(), m = t.length();

        int[][] f = new int[m + 1][26];
        for (int i = 0; i < 26; i++) {
            f[m][i] = m;
        }

        for (int i = m - 1; i >= 0; i--) {
            for (int j = 0; j < 26; j++) {
                if (t.charAt(i) == j + 'a')
                    f[i][j] = i;
                else
                    f[i][j] = f[i + 1][j];
            }
        }
        int add = 0;
        for (int i = 0; i < n; i++) {
            if (f[add][s.charAt(i) - 'a'] == m) {
                return false;
            }
            add = f[add][s.charAt(i) - 'a'] + 1;
        }
        return true;
    }
}

传递信息

在这里插入图片描述

class Solution {
    public int numWays(int n, int[][] relation, int k) {
        int[][] dp = new int[k + 1][n];
        dp[0][0] = 1;
        for (int i = 0; i < k; i++) {
            for (int[] edge : relation) {
                int src = edge[0], dst = edge[1];
                dp[i + 1][dst] += dp[i][src];
            }
        }
        return dp[k][n - 1];
    }
}
【动态规划】 最简入门教程
songhk0209的博客
01-16 688
看了本文还入不了门，那就基本告别动态规划了 : ) ~ 一、简介 二、【能用】动态规划解决的问题 三、【适合用】动态规划解决的问题 四、动态规划求解的3个关键步骤 1. 建立状态转移方程 2. 缓存小规模答案以复用，避免重复计算 3. 按规模顺序从小到大求解，且最小的几个答案必须手动给出 五、实例 实例1 —— 斐波那契数列 实例2 - ...
【算法】C++动态规划+滚动数组（面试极其加分的代码）
weixin_41118203的博客
07-06 2293
动态规划解题步骤思路例题 解题步骤 动态规划解题步骤： 确定原问题与子问题 确认状态，dp[i]数组的意义 确认边界状态的值 确认状态转移方程 思路 看到OJ题求最值，一般使用贪心或者动态规划。如果贪心不能解而且原问题规模可缩小，可用动态规划求解 先把原问题的规模缩成最小的子问题，确定边界 逐步扩大子问题，并且通过前面步骤的子问题的解来求最新子问题的解 当子问题规模扩大为i时，可推出状态转移方程 例如：原问题dp[i]的解=子问题dp[i-1]的解+子问题dp[i-2]的解 d
动态规划（一）一一状态定义和状态转移方程
热门推荐
qq_40963043的博客
09-12 3万+
动态规划真让人看得头疼，这只是一种思想，并没有一定的解题规律，当问题出现的时候，对于不太熟悉动态规划的人来说，确实有点难以想到，一般都是采用暴力求法。这里贴一个知乎链接，我觉得动态规划讲的还挺好的，什么是动态规划？ 嘿嘿，也不知道会不会有人还会跳回来看看，哈哈。反正是写给自己的，问题不大。既然理解了上面是动态规划，就来几个简单的题目来练练手（题目来源leetcode）。 1 最大子序和 ...
滚动数组详解
最新发布
weixin_73557167的博客
03-19 465
滚动数组
滚动数组（简单说明）
weixin_47750287的博客
02-24 1万+
前提概要 首先呢，滚动数组是一种能够在动态规划中降低空间复杂度的方法， 有时某些二维dp方程可以直接降阶到一维，在某些题目中甚至可以降低时间复杂度，是一种极为巧妙的思想， 简要来说就是通过观察dp方程来判断需要使用哪些数据，可以抛弃哪些数据， 一旦找到关系，就可以用新的数据不断覆盖旧的数据量来减少空间的使用， 接下来我会介绍一些简单例题来具体解释一下滚动数组的作用。 先以斐波那契数列为例 我们先以斐波那契数列来简单感受一下滚动数组的魅力，先上一段经典的代码（使用滚动数组） #include<bits/
【动态规划】01背包问题（滚动数组 + 手画图解）
这个人很勤快，但还是什么也没有。
02-11 6814
一、滚动数组的基本理解我对于滚动数组的理解是：滚动数组是基于二维数组之上产生的，之所以滚动数组能够用一维的方式去完成和二维同样的工作，原因就是在于这个滚动数组能够重复产生数据，进而有“滚动”的效果。滚动数组的本质还是二维数组，只是数据不再产生新的行，只在一行上一直进行数据的覆盖更新，因此要特别注意数据污染的情况。
leetcode中文版-leetcode:算法笔记总结。包括《剑指offer》《程序员笔试面试指南》《Leetcode》相关题目
06-29
LeetCode专题训练 回溯法： 链表 ： 动态规划： 排序专题： 程序员代码面试指南 : chapter2 : 链表部分题目： LeetCode官方算法精选 初级算法49题： 数组系列： 字符串系列 链表系列 二叉树系列 排序系列 动态规划...
leetcode题库-LeetCode:刷题记录
06-29
top_interview_questions_easy包为初级算法专题记录。 top_interview_questions_medium包为中级算法专题记录。 top_interview_questions_hard包为高级算法专题记录。 recursion_i包为递归I专题记录。 其它 random_...
leetcode分类-AlgoExplained:算法解释
06-30
这份资料分为三个主要部分，分别聚焦于数据结构、LeetCode题目讲解以及按照算法名称分类的专题讨论。 首先，数据结构部分是算法的基础，它涵盖了数组、链表、栈、队列、树、图、哈希表等多种经典数据结构。在...
LeetCode平台与开源项目：深度解析leetcode-master
4. 学习资源: 除了常规题目外，leetcode还提供了专题学习模块，如数组、字符串、链表、树、图等，以及动态规划、回溯算法等专题。用户可以系统地学习和练习特定主题，从而更加深入地掌握相关算法和数据结构知识。 5...
Leetcode专题问题解决方案库：C++语言实现
此存储库可能包含按主题分类的算法问题解决方案，例如数组、字符串、链表、树、图等数据结构，以及排序、搜索、动态规划等算法。每个算法问题都可能包含了代码实现、问题描述、测试用例和复杂度分析。使用这样的存储...
滚动数组-动态规划（跳跃训练-费波那契数列）
csdnuu123的博客
10-21 1129
解法空间复杂度适用场景优点缺点动态规划（DP）O(n)大多数动态规划问题逻辑清晰，易于理解，适用于多维问题空间复杂度高滚动数组（空间优化）O(1)状态转移依赖少的动态规划问题（如斐波那契数列）空间复杂度低，节省内存只适用于状态依赖较少的情况，不适用复杂的多维问题当问题的状态转移方程简单且依赖的状态较少时，滚动数组解法非常适合。然而，对于依赖更多前置状态或复杂多维问题，滚动数组解法的应用局限性会显现出来。
广度优先搜索算法①-滚动数组及BFS
灰灰老师
12-05 1589
无向图（Undirected Graph） 是一种数据结构，用于表示一组对象（称为顶点或节点）以及它们之间的关系（称为边）。在无向图中，每条边都没有方向，这意味着从一个顶点到另一个顶点的关系是双向的。( V ) 是一个非空集合，包含图中的所有顶点。( E ) 是一个由 ( V ) 中元素构成的二元组（即有序对）的集合，表示图中的边。对于一条边 ( (u, v) )，它表示顶点 ( u ) 和顶点 ( v ) 之间存在一条连接。
关于滚动数组的一些初学随笔
chengxuyuanlaow的博客
10-13 548
简单来说，滚动数组就是一种具有短暂记忆力的数组，它会牺牲时间来节省空间，用size=3的数组来“存储”30000个数据。这么说有点离谱、抽象，毕竟a[3]怎么存储a[30000]里面的东西呢。这就是滚动数组的特性，即只记录少量的后续需要使用的数据，而将之前用过且不再需要调用的数据抛弃、覆盖，这样就将a[30000]中不要的数据所占的空间节省出来，以达到a[3]就能达成的任务目标。
滚动数组
你的代码 受命于你
07-22 781
1.滚动数组是什么?     一个及其小巧的思维,数据结构都算不上,不过非常适用于某些问题节约空间.其实就是一个长度为2的循环队列的概念. 2.滚动数组有什么用?     在处理一些问题特别是DP这类问题时经常需要递推,用数组记录数据是必不可少的,然而n过大时开n*n的数组会爆栈,而滚动数组可以将空间缩为2*n.     可处理的问题多表现为多步的数据递推,而且每一步递推只会用到上一次递推...
滚动数组-动态规划之-不同路径 II_20230421
Jasonchen1224的博客
04-22 939
滚动数组， 动态规划，算法，C语言
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值