算法Day7：动态规划——背包、序列专题

最新推荐文章于 2024-02-26 07:00:00 发布
最新推荐文章于 2024-02-26 07:00:00 发布
阅读量1.4k 收藏 4
点赞数 5
分类专栏： # 备战蓝桥杯 文章标签： 动态规划 算法 01背包问题 完全背包 最长上升子序列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/105084391
版权

蓝桥杯算法合集： 蓝桥杯算法合集（终极完结版）

算法Day6：动态规划

动态规划

动态规划一般是用来解决最优子结构或者是子问题最优性，这类问题常见有重叠子问题。比如像递归解决斐波那契数列、爬楼梯方案数等。会发现递归调用过程中存在重复计算。对调用过程进行记忆化也是dp的一种体现。

思路：
我自己写的话一般是用画图工具（也可以用excel），列出表格，从小范围根据递推基一步一步去推，进而发现状态转移方程。
用一个表（常见数组）来记录所有已解子问题的答案。不管该子问题以后是否被用到，只要他被计算过就将结果填入表中，也叫打表法。

一般步骤：

  1. 确定状态（一是般先确定dp数组所表示的意义）
  2. 找到状态转移方程
    要找状态方程可以这样思考，当前面临一个状态，它有可能是从哪儿来的？dp问题通常要逆向思考达到当前这个状态的最后一步，即压死骆驼的最后一根稻草。

本阶段状态=（上一个阶段状态+上一个阶段决策）
状态转移方程要保证当前状态可以接到所有该转移状态的转移。

解法形式：
自顶向上：递归 如果有重叠子问题，带备忘录。比如递归求斐波那契数列还有爬楼梯方案数（这也是dp解法的一种形式，会发现使用带备忘录的递归通常可以ac）。
自底向下：递推
应用：

  • 01背包
  • 完全背包问题
  • 最长上升子序列问题
  • 最长公共子序列

总结有

  • 序列专题：
  • 背包专题：

刷题过程中的小知识点：
（1）子矩阵不一定要取自原矩阵的连续行和列
有些初学者可能会认为，子矩阵一定是如下图这种取自原矩阵连续行列的矩阵。
注意边界处理
原矩阵：
1 2 3
4 5 6
7 8 9

子矩阵：
1 2 3
4 5 6

其实子矩阵不一定取自原矩阵的连续行列，也可以是不连续行或者列：
1 2
4 5
或
1 3
4 6
7 9
（2）、子序列不一要求连续但是子串要连续

背包问题专题

背包问题常见以下几种

01背包
模型特点：每种物品只有一个，且要么选要么不选，有01两种状态因而以01得名。有限制范围，常见体积或者重量限制，一般用二维数组dp[i][j]表示状态,其中第一个维度表示可选范围，第二个维度表示容量等限制范围。

完全背包
模型特点：与01背包相似，唯一不同的是，完全背包的物品是由无限个。

01背包问题

/*
题目描述
给定N个物品,每个物品有一个重量W和一个价值V.你有一个能装M重量的背包.问怎么装使得所装价值最大.每个物品只有一个.
输入
输入的第一行包含两个整数n, m，分别表示物品的个数和背包能装重量。
以后N行每行两个数Wi和Vi,表示物品的重量和价值
输出
输出1行，包含一个整数，表示最大价值。
样例输入
3 5
2 3
3 5
4 7
样例输出
8
 
4 5
2 3
1 2
3 4
2 2
得到的dp矩阵：
0 0 3 3 3 3
0 2 3 5 5 5
0 2 3 5 6 7
0 2 3 5 6 7
 *
 */

在这里插入图片描述

 package 动态规划;
import java.util.Scanner;
public class _01背包问题_动态规划 {
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        int n=reader.nextInt();//物品个数
        int m=reader.nextInt();//背包承重量
        int[] w=new int[n];//存放每个物品的重量
        int[] v=new int[n];//存放每个物品的价值
        for(int i=0;i<n;i++) {
            w[i]=reader.nextInt();
            v[i]=reader.nextInt();
//dp[i][j]中第一个维度表示可选范围 第二个维度表示容量
        }
        int [][]dp=new int[n][m+1];
        //初始化dp数组第一行
        for(int i=0;i<=m;i++) {//w[0]<i 中的i刚好可以表示背包容量
            if(w[0]<=i) {//放得下0号物品
                dp[0][i]=v[0];
            }
        }
        for(int i=1;i<n;i++) {
            for(int j=0;j<=m;j++) {
                if(w[i]<=j) {
                    int v1=dp[i-1][j];//不要当前这个物品
                    int v2=dp[i-1][j-w[i]]+v[i];//要当前这个物品
                    dp[i][j]=Math.max(v1, v2);
                }else {
                    dp[i][j]=dp[i-1][j];
                }
            }
        }
        System.out.println(dp[n-1][m]);
//      for(int i=0;i<n;i++) {
//          for(int j=0;j<=m;j++) {
//              System.out.print(dp[i][j]+" ");
//              }
//          System.out.println();
//      }

完全背包问题

/*
有 N 种物品和一个容量是 V
的背包，每种物品都有无限件可用。
第 i种物品的体积是 vi，价值是 wi
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V
，用空格隔开，分别表示物品种数和背包容积。
接下来有 N
行，每行两个整数 vi,wi，用空格隔开，分别表示第 i
种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10
链接：
https://www.acwing.com/problem/content/description/3/
 */
package 动态规划;
import java.util.Scanner;
public class 完全背包问题 {
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        int n=reader.nextInt();//物品个数
        int m=reader.nextInt();//背包承重量
        int[] w=new int[n];//存放每个物品的重量
        int[] v=new int[n];//存放每个物品的价值
        for(int i=0;i<n;i++) {
            w[i]=reader.nextInt();
            v[i]=reader.nextInt();
        }
        int[][] dp=new int[n][m+1];
        //初始化dp数组第一行
        for(int i=0;i<m;i++) {
            if(w[0]<=i) {
                dp[0][i]=v[0]+dp[0][i-w[0] ];
            }
            
        }
        for(int i=1;i<n;i++) {//i表示行号 同时也是物品号
            for(int j=1;j<=m;j++) {//j表示列好 同时也是背包容量
                if(w[i]<=j) {
                    int v1=v[i]+dp[i][j-w[i]];//选当前物品
                    int v2=dp[i-1][j];
                    dp[i][j]=Math.max(v1,v2);
                }else {
                    dp[i][j]=dp[i-1][j];
                }
                
            }
        }
//      for(int i=0;i<n;i++) {
//          for(int j=1;j<=m;j++) {
//              System.out.print(dp[i][j]+" ");
//          }
//          System.out.println();
//      }
        System.out.println(dp[n-1][m]);
        
    }
}
    }
}

序列专题

动态规划常见序列模型专题有以下几种：

最大子段问题

最长上升子序列
dp[i]表示以i号元素为结尾的最长上升子序列长度

最大公共子序列
dp[i][j]表示s1前i个元素和s2前j元素的公共子列长度

最大子段和问题

最大子段和问题
最大子段和就是所有子段中和最大的
例如：
-2 11 -4 13 - 5 -2
最大子段和就是：11+（-4）+13=20
在这里插入图片描述

package 常见动态规划模型;
/*
测试数据：
6
-2 11 -4 13 -5 -2
答案：
20
*/


import java.util.Scanner;
public class 最大子段和 {
    static int INF=0x7fffffff;//16进制表示的最大整数
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        int n=reader.nextInt();
        int []num=new int[n+1];
        for(int i=0;i<n;i++) {
            num[i]=reader.nextInt();
        }
        int ans=-INF;
        for(int i=0;i<n;i++) {//如果序列全为非正数 最大子段和为最大值
            ans=Math.max(ans, num[i]);
        }
        if(ans<=0) {//特判掉全为非正数的情况
            System.out.println(ans);
        }else{//序列有正也有负
            int sum=0;
            for(int i=0;i<n;i++) {
                if(sum+num[i]<=0) {
                    sum=0;
                }else {//以i号元素为结尾的序列有正向作用
                    sum=sum+num[i];
                }
                ans=Math.max(ans, sum);//看看是否需要更新ans
            }
            System.out.println(ans);
        }
    }
}

最长上升子序列

在这里插入图片描述
在这里插入图片描述

package 常见动态规划模型;
/*
测试数据：
6
3 2 6 1 4 5
答案：3
6
4 10 4 3 8 9
答案：3
*/
import java.util.Scanner;
public class 最长上升子序列 {
    static int n;
    static int []a;
    static int []dp;
    //dp[i]表示以i号元素结尾的最长上升子序列个数
    //状态方程：dp[i]=max(dp[i],dp[j]+1) (1<=j<i  && a[j]<a[i])
    //时间复杂度：O（n^2）
    static int LIS() {
        int ans=0;
        for(int i=1;i<=n;i++){
            
            dp[i]=1;//初值
            for(int j=1;j<i;j++) {
                if(a[j]<a[i]) {//更新为较大者
                    dp[i]=Math.max(dp[i],  dp[j]+1);
                }
            }
            ans=Math.max(ans, dp[i]);
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        n=reader.nextInt();
        dp=new int[n+1];
        a=new int[n+1];
        for(int i=1;i<=n;i++) {
            a[i]=reader.nextInt();
        }
        System.out.println(LIS());
    }
}

最长公共子序列

dp表
在这里插入图片描述
再举个例子
在这里插入图片描述

package 动态规划;
public class 最长公共子序列 {
    
    /**递归
     * @param nums1
     * @param i 表示nums1数组的前i个
     * @param nums2
     * @param j 表示nums2数组的前j个
     * @return 最长公共子序列的长度
     * 空间复杂度：O(Math.min(m,n) 递归深度*辅助空间
     * 时间复杂度：O(2^n)
     */
    int LongestCommonSubsequence0(String s1,int  i,String s2,int j) {
        if(i==0||j==0||s1==null||s2==null)return  0;
        if(s1.charAt(i-1)==s2.charAt(j-1)) {
            return  LongestCommonSubsequence0(s1,i-1,s2,j-1)+1;
        }
        //返回nums1前i个与nums2前j-1个 和 nums1前i-1个与nums2前j个最长公共子序列的较大者
        return  Math.max(LongestCommonSubsequence0(s1,i,s2,j-1  ),
                LongestCommonSubsequence0(  s1,i-1,s2,j ) );
    }
    
    //动态规划解法
    /**确定状态 dp[i][j] 表示s1的前i个字符与s2的前j个字符的公共子序列长度
     * 递推基 dp[0][j] 和 dp[i][0]都为0
     * @param s1
     * @param s2
     * @return dp[len1][len2]即为s1和s2的最大公共子序列长度
     * 空间复杂度:O(m*n)
     * 时间复杂度:O(m*n)
     *
     */
    int LongestCommonSubsequence1(String  s1,String s2) {
        if(s1==null||s2==null)return 0;
        int m=s1.length();
        int n=s2.length();
        int [][]dp=new int [m+1][n+1];
        for(int i=1;i<=m;i++) {//枚举每一行
            for(int j=1;j<=n;j++) {
                if(s1.charAt(i-1)==s2.charAt(j-1)) {
                    dp[i][j]=dp[i-1][j-1]+1;
                }else {
                    dp[i][j]=Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[m][n];
    }
    /**
     * 优化空间复杂度为O(2*(m或n))
     * 使用两行的滚动数组存储状态
     * 字符串为空即 "" 存在对象但length为0
     * 与字符串等于null不一样 为null表示该对象不存在 不能调用字符串的方法
     * @param s1
     * @param s2
     * @return
     */
    int LongestCommonSubsequence2(String  s1,String s2) {
        if(s1==null||s2==null)return 0;
        int m=s1.length();
        int n=s2.length();
        if(m==0||n==0) return 0;
        int [][]dp=new int [2][n+1];
        for(int i=1;i<=m;i++) {
            for(int j=1;j<=n;j++) {
                if(s1.charAt(i-1)==s2.charAt(j-1)) {
                    dp[i%2][j]=dp[(i-1)%2][j-1]+1;
                }else {
                    dp[i%2][j]=Math.max(dp[(i-1)%2][j],  dp[i%2][j-1]);
                }
            }
        }
        return dp[m%2][n];
    }
    int LongestCommonSubsequence3(String  s1,String s2) {
        if(s1==null||s2==null)return 0;
        int m=s1.length();
        int n=s2.length();
        if(m==0||n==0) return 0;
        int []dp=new int[n+1];
        for(int i=1;i<=m;i++) {
            int cur=0;
            for(int j=1;j<=n;j++) {
                int lefttop=cur;
                cur=dp[j];
                if(s1.charAt(i-1)==s2.charAt(j-1)) {
                    dp[j]=lefttop+1;
                }else {
                    dp[j]=Math.max(dp[j-1],  dp[j]);
                }
            }
            
        }
        return dp[n];
    }
    /**
     * 使用一维数组 包含上一行部分dp值和本行部分dp值
     * @param s1
     * @param s2
     * @return
     */
    int LongestCommonSubsequence4(String  s1,String s2) {
        if(s1==null||s2==null)return 0;
        int m=s1.length();
        int n=s2.length();
        if(m==0||n==0) return 0;
        int []dp=new int[n+1];
        for(int i=1;i<=m;i++) {
            int lefttop=0;//换到下一行之后要清零
            for(int j=1;j<=n;j++) {
                if(s1.charAt(i-1)==s2.charAt(j-1)) {
                    //覆盖前先保存dp[j] 该值为下一个的左上
                    int now=dp[j];
                    dp[j]=lefttop+1;
                    lefttop=now;
                }else {
                    lefttop=dp[j];
                    dp[j]=Math.max(dp[j-1],  dp[j]);
                }
            }
            
        }
        return dp[n];
    }
    
    /**
     * 以长度较小者作为dp的长度
     * @param s1
     * @param s2
     * @return
     */
    int LongestCommonSubsequence5(String  s1,String s2) {
        if(s1==null||s2==null)return 0;
        if(s1.length()==0||s2.length()==0)  return 0;
        String rowNums,colNums;
        //s1长度比s2大
        if(s1.length()>s2.length()) {
            rowNums=s1;
            colNums=s2;
        
        }else {
            rowNums=s2;
            colNums=s1;     
        }
        
        int []dp=new int[colNums.length()+1];
        for(int i=1;i<=rowNums.length();i++) {
            int cur=0;
            for(int j=1;j<=colNums.length();j++)  {
                int lefttop=cur;
                cur=dp[j];
                if(rowNums.charAt(i-1)==colNums.charAt(j-1)) {
                    dp[j]=lefttop+1;
                }else {
                    dp[j]=Math.max(dp[j-1],  dp[j]);
                }
            }
            
        }
        return dp[colNums.length()];
    }
    public static void main(String[] args) {
        String s1="BA34C";
        String s2="A1BC2";
        int len1=s1.length();
        int len2=s2.length();
        最长公共子序列 a=new 最长公共子序列();
        System.out.println(a.LongestCommonSubsequence0(s1,len1,s2,len2));
        System.out.println(a.LongestCommonSubsequence1(s1,s2));
        System.out.println(a.LongestCommonSubsequence2(s1,s2));
        System.out.println(a.LongestCommonSubsequence3(s1,s2));
        System.out.println(a.LongestCommonSubsequence4(s1,s2));
        System.out.println(a.LongestCommonSubsequence5(s1,s2));
    }
}
JohnnyLin00
关注
专栏目录
华为OD机试 - Wonderland游乐园 - 动态规划（Java 2024 D卷 200分）
学Java，找哪吒
07-24 1296
动态规划（Dynamic Programming, DP）是一种解决最优子结构问题的算法。
算法训练Day43 | LeetCode1049. 最后一块石头的重量II(尽可能装最多能装多少）； 494. 目标和（求装满背包有多少种方法）；474.一和零（给背包容量，装满背包最多有多少个物品）
weixin_47284299的博客
12-10 771
算法训练Day43 | LeetCode1049. 最后一块石头的重量II(尽可能装最多能装多少）; 494. 目标和（求装满背包有多少种方法）；474.一和零（给背包容量，装满背包最多有多少个物品）
超递增序列背包问题
taotao 的大学墓志
08-19 6618
问题描述背包密码曾被用做公钥密码，因为对于平凡的序列<a1,...,ai,...,an><a_1,...,a_i,...,a_n>目前的最优时间复杂度为O(2n/2)O(2^{n/2}) 但我们可以在O(n)O(n)的时间复杂度内解决序列为超递增的情况。应用于背包密码的背包问题给定一个序列<a1,...,ai,...,an><a_1,...,a_i,...,a_n>与值SS从中选出一些数使他们的和为
动态规划——背包专题
qq_45589658的博客
08-17 181
背包问题是一类典型的动态规划问题，背包问题又分为：0-1背包、完全背包、多重背包这三类。本文将介绍这三种背包问题以及acm题目代码。其中多重背包部分有很多类型的变式，因此给出的题目较多。 一、0-1背包 0-1背包问题通常为：给定n个物品、每个物品的体积为w[i]，价值为c[i]。（每个物品只有一件）背包的容量为V，问如何选取物品使得不超过背包的容量且所装总价值最大。 一般的状态转移方程可以写为： dp[i][j]=max{dp[i−1][j]不放第i件物品dp[i−1][j−w[i]]+c[i]放第i件物
动态规划
T0UGH
03-10 163
动态规划(Dynamic Programing, DP)动态规划是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间远少于朴素解法 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分，再根据子问题的解以得出原问题的解 ...
dp——动态规划练习1（最长公共子序列问题、01背包问题）
筱羊冰冰
12-26 330
最长公共子序列问题 简介 首先给出公共子序列的定义，即两个字符串中相同的子串，比如ababa和babd中的公共子序列有b、ba、ab、bab；而ababa和babca中，公共子序列为baba。（即中间可以相隔） 所以我们可以这样总结，将两个字符串进行一定的删减，但不能改变元素顺序，最终得到的两个相同的子串，那么这个字串就是两个串的公共子序列。 这个问题中我们需要寻找最大的子序列。 分析 要使用dp就一定要先证明可以使用，关于证明的部分在这里。我们需要证明存在重叠子问题和优化子结构。 首先，我们可以看出这个问
春节7天练丨Day7：贪心、分治、回溯和动态规划1
08-03
5. 最大乘积子序列：动态规划问题，找出数组中连续子序列的最大乘积。 6. 三角形最小路径和：类似于最小路径和问题，动态规划方法可用于找到穿过三角形的最小路径和。 7. 八皇后问题：回溯算法的典型应用，放置皇后...
每日刷题计划Day5+Day6+Day7+Day8-动态规划+背包问题合集
布屿
01-27 636
题源：ACwing 01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤100
算法训练Day38 | 动态规划理论基础；LeetCode509. 斐波那契数；70. 爬楼梯；746. 使用最小花费爬楼梯
weixin_47284299的博客
10-30 575
算法训练Day38 | 动态规划理论基础；LeetCode509. 斐波那契数；70. 爬楼梯；746. 使用最小花费爬楼梯
动态时间规整_动态规划-数组系列(10%)
weixin_39640008的博客
12-02 422
哇呀呀呀呀~~~好！实不相瞒，小弟我就是人称玉树临风胜潘安，一支梨花压海棠的小淫虫周伯通！《唐伯虎点秋香》 不同路径 II​leetcode-cn.com 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将...
动态规划的时间复杂度优化
最新发布
闻缺陷则喜何志丹
02-26 5114
优化动态规划的时间复杂度，主要有如下几种：
[学习笔记]动态规划的一些基本概念和杂项
Andrewzdm的小窝
01-07 415
动态规划是什么？ 在学习一个算法之前，我们肯定要知道它是什么。 在笔者看来，与其说动态规划是一种算法，不如说它是一个思想。 怎样的思想呢？ 将大问题分解成本质相同但规模更小的子问题求解，再根据子问题的解求出原问题的解。这和分治算法的思想极为类似。 不做重复的事情。如果一个问题已经被求解过了，我们就不要再求解它了。 说到这儿可能很抽象，我们来根据实际问题举一个例子： Luogu P1255 数楼梯 （先不要考虑高精度算法。） 这是一个十分基础的动态规划问题。 首先，如果你不会动态规划，那么你的想法应该是暴
蓝桥杯一些常用的算法
qq_52897257的博客
04-05 5874
蓝桥杯倒计时（常用算法合集）
蓝桥杯攻略大全 | 学习路线 | 注意事项
欢迎关注，一起进步！
03-07 2万+
蓝桥杯攻略 一.语法基础 想参加算法竞赛就必须会使用一门编程语言，编程语言是竞赛的基础，如果你还没有学习编程就想参加蓝桥杯，那么我建议你先去学习一门编程语言，这里推荐C/C++，因为C语言更适合算法竞赛，java这种严谨的语言更适合做项目使用，不过如果你已经学习了java或者python等也没有问题的啦，毕竟这三个语言都是可以参加蓝桥杯的。语法学习我建议在7-14天，多多练习巩固语法知识。 如果你目前还很迷茫，请务必看完，应该会对你的学习过程有所帮助，如果你已经有目标了，可以把这篇文章当作查漏补缺。
蓝桥杯常考算法总结
qq_45902401的博客
06-05 8329
2.常考题型 1.比较排序 比较排序是小白最容易想到的排序方法，从第一个元素开始，和后面所有元素依次进行比较，比第一个元素小，就将这两个元素交换，最后比完第一轮，第一个元素肯定是最小的了，然后从第二个元素开始，和后面所有元素比较，一轮比完，第二个元素是第二小的，同理，比完n-1（n为数组元素个数）轮，数组全部变得有序。比较排序是稳定的，也就是遇到值一样大的情况下不会发生交换，保持原来位置，其时间复杂度为O(n^2),代码如下： public class Test比较 { public static voi
写给零基础入坑蓝桥杯的同学
热门推荐
阿璐4r的博客
07-18 7万+
以下为2020.1.9更新
动态规划-时间规整算法
guomutian911的专栏
01-22 6440
DTW(Dynamic Time Warping,动态时间归整)算法,该算法基于动态规划(DP)的思想,解决了发音长短不一的模板匹配问题,是语音识别中出现较早、较为经典的一种算法。
动态规划——背包问题（详解）
qq_61896131的博客
03-08 9185
动态规划是我最早接触的算法，一开始非常简单，固定模板题，后来愈发愈发难起来了，条件，状态压缩等等，难点主要是，状态怎么表示，状态转移方程怎么写，这篇文章将会从背包五大问题详解，希望能帮助到大家去类比，思考其他动态规划题目。 首先先来看看动态规划的定义： 动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。
ACM算法模板：动态规划与背包问题解析
"ACM算法模板合集包含了ACM竞赛中常见的算法模板，如动态规划、最长公共子序列以及背包问题的解决方案。" 在ACM算法竞赛中，掌握高效的算法和模板是至关重要的。以下是对这些算法的详细解释： 1. **动态规划...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值