动态规划

最新推荐文章于 2024-10-15 17:06:18 发布

李昌晋

最新推荐文章于 2024-10-15 17:06:18 发布

阅读量1k

点赞数 30

分类专栏：数据结构与算法文章标签：动态规划算法

本文链接：https://blog.csdn.net/weixin_55245206/article/details/141065673

版权

数据结构与算法专栏收录该内容

20 篇文章 0 订阅

订阅专栏

最大连续子段和

思路： $d p [i]$ 表示以 $a [i]$ 结尾的最大连续子段和，那么 $d p [i] = M a t h . ma x (d p [i - 1] + a [i], a [i])$ ，如果 $d p [i - 1]$ 是小于 $0$ 的，那么最大值就是 $a [i]$ ，否则，最大值就是 $d p [i - 1] + a [i]$ ，最终结果就是 $d p$ 数组中的最大值。

public static int len(int[] a){
    int[] dp = new int[a.length];
    dp[0] = Math.max(0,a[0]);
    int max = Integer.MIN_VALUE;
    for(int i=1;i<a.length;i++){
        dp[i] = Math.max(dp[i-1]+a[i],a[i]);
        if(max<dp[i])
            max = dp[i];
    }
    return max;
}

$L CS$ 最长公共子序列

思路：

1.用一个数组 $d p [i] [j]$ 表示 $S$ 字符串中前 $i$ 个字符与 $T$ 字符串中前 $j$ 个字符的最长上升子序列，那么 $d p [i + 1] [j + 1]$ 就是S 字符串中前 i+1 个字符与 $T$ 字符串中前 $j + 1$ 个字符的最长上升子序列；

2.如果此时 $S$ 中的第 $i + 1$ 个字符与 $T$ 中的第 $j + 1$ 个字符相同，那么 $d p [i + 1] [j + 1] = d p [i] [j] + 1$ ;

3.如果此时 $S$ 中的第 $i + 1$ 个字符与 $T$ 中的第 $j + 1$ 个字符不同，那么 $d p [i + 1] [j + 1] = M a t h . ma x (d p [i + 1] [j], d p [i] [j + 1])$ ;

public static int LCS(String s,String t){
    int[][] dp=new int[s.length()+1][t.length()+1];
    for(int i=1;i<=s.length();i++){
        for(int j=1;j<=t.length();j++){
            if(s.charAt(i-1)==t.charAt(j-1))
                dp[i][j]=dp[i-1][j-1]+1;
            else
                dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
        }
    }
    return dp[len1][len2];
}

$L CS$ 最长公共子序列及其个数

思路：

1.在最长公共子序列的基础上稍作修改即可；

2.如果 $s [i] == t [j]$ ，此时公共子序列的长度增加 $1$ ，其子序列个数至少与 $n u m [i - 1] [j - 1]$ 的个数相同，所以个数不变；

3.如果 $d p [i] [j] == d p [i] [j - 1]$ (即两者的长度相同,但内容不同或顺序不同) 则 $n u m [i] [j] + = n u m [i] [j - 1]$ ;

4.如果 $d p [i] [j] == d p [i - 1] [j]$ ，则 $n u m [i] [j] + = n u m [i - 1] [j]$ ；

5.如果 $d p [i] [j] == d p [i - 1] [j - 1]$ ，则 $n u m [i] [j] - = n u m [i - 1] [j - 1]$ ；（因为如果 $3$ 和 $4$ 同时触发则会出现加了两次 $n u m [i - 1] [j - 1]$ 的情况，所以要剪掉）；

public static void LCS(String a,String b){
    char[] s = s.toCharArray();
    char[] t = b.toCharArray();
    int[][] dp = new int[s.length+1][t.length+1];
    int[][] num = new int[s.length+1][t.length+1];
    for(int i=0;i<s.length;i++) num[i][0] = 1;
    for(int i=0;i<t.length;i++) num[0][i] = 1;
    for(int i=1;i<=s.length;i++) {
        for(int j=1;j<=t.length;j++) {
            if(s[i-1]==t[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
                num[i][j] = num[i-1][j-1];
            }else {
                dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
            }
            if(dp[i][j]==dp[i][j-1])
                num[i][j] = num[i][j] + num[i][j-1];
            if(dp[i][j]==dp[i-1][j])
                num[i][j] = num[i][j] + num[i-1][j];
            if(dp[i][j]==dp[i-1][j-1])
                num[i][j] = num[i][j] - num[i-1][j-1];
            num[i][j] %= N;
        }
    }
}

$L I S$ 最长上升子序列

动态规划方法 $O( n_2 )$ ：

思路：用 $d p$ 数组表示以 $i$ 结尾的最长上升子序列，那么 $d p [i]$ 的结果就为：前 $i$ 个比 $a [i]$ 小的数中 $d p$ 数组中的最大值 $+ 1$ ， $d p$ 数组中的最大值，便是此序列的最长上升子序列长度；

public static int LIS(int[] a){
    int[] dp = new int[a.length+1];
    dp[0] = 0;
    int num  = 0;
    for(int i=1;i<a.length;i++) {
        int max = 0;//前面的最大dp值
        for(int j=1;j<=i;j++) {//判断前面的数
            if(a[i]>a[j]) {//保证上升
                if(dp[j]>max)
                    max = dp[j];//在保证上升的前提之下，找到最大值
            }
        }
        dp[i] = max+1;//长度加上i本身
        num = Math.max(max, dp[i]);
    }
    return num;
}

贪心方法 $O( nlog_2n )$ ：

思路：用一个数组 $f$ 表示上升子序列的长度为 $i$ 时的末尾元素最小值，用二分法查找 $a [i]$ 可以放入 $f$ 数组中的最优位置，并将其放入，记录 $f$ 数组用到的长度即为最长上升子序列的长度；

public static int number(int[] a){
    int[] f = new int[a.length];//长度为i的上升子序列的末尾元素最小值为f[i]
    int length = 0;
    for(int i=0;i<n;i++) {
        int l = 0;
        int r = length;
        while(l<r) {
            int mid = (l+r+1)>>1;
            if(f[mid]>=a[i])
                r = mid - 1;
            else
                l = mid;
        }
        length = Math.max(length, r+1);
        f[r+1] = a[i];
    }
    return length;
}

最大连续子矩阵和

思路：

1.将矩阵中的每一个元素的值都转变为它同一列前 $i - 1$ 行的元素和，那么便可以通过前缀和数组获得到任意上下区间中的元素和，也就变为了一维问题；

2.求这一个上下区间内的最大连续子段和，也就是找上下区间固定的所有子矩阵的最大连续和；

public static int subMaxMatrix(int[][] g){
    for(int i=1;i<=g.length;i++)
        for(int j=1;j<=g[i].length;j++)
            g[i][j] += g[i-1][j];//前缀和初始化
    int ans = Integer.MIN_VALUE;
    for(int start=1;start<=g.length;start++){
        for(int end=1;end<=g[i].length;end++){//枚举start行~end行
            int dpi = 0;
            for(int col = 1;col<=g[i].length;col++){
                int ai = g[end][col] - g[start-1][col];
                dpi = Math.max(dpi+ai,ai);
                ans = Math.max(dpi,ans);
            }
        }
    }
    return ans;
}

背包专题

$01$ 背包

题目链接：小明的背包1 - 蓝桥云课 (lanqiao.cn)

思路：

1.用一个二维数组 $d p$ 表示考虑前 $i$ 件物品，在背包容量为 $j$ 的时候能取得的最大价值，当 $i$ 或者 $j$ 为 $0$ 的时候， $d p$ 值为 $0$ ；

2.每一件物品都可以有两个情况——选 $or$ 不选，如果不选此件物品，那么 $d p$ 的结果与考虑前 $i - 1$ 件物品在相同背包容量时能取得的最大价值相同，如果选择，那么 $d p$ 的结果为这件物品能带来的价值 $+$ 考虑前 $i - 1$ 件物品，在背包容量为（放入这件物品后剩余大小）时能取到的最大价值，两个取最大值；

3.状态转移方程为： $d p [i] [j] = M a t h . ma x (d p [i - 1] [j], v [i] + d p [i - 1] [j - w [i]])$ ；

4.最终结果即为 $d p [n] [m]$ ；

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc =  new Scanner(System.in);
		int n = sc.nextInt();//商品数量
		int m = sc.nextInt();//背包的容量
		int[] w = new int[n+1];
		int[] v = new int[n+1];
		for(int i=1;i<=n;i++) {
			w[i] = sc.nextInt();//体积
			v[i] = sc.nextInt();//价值
		}
		int[][] dp = new int[n+1][m+1];//1 ~ n
		for(int i=0;i<=n;i++) {
			for(int j=0;j<=m;j++) {
				if(i==0 || j==0)
					dp[i][j] = 0;
				else {
					if(j<w[i]) {
						dp[i][j] = dp[i-1][j];
					}else {//j>=w[i]
						dp[i][j] = Math.max(dp[i-1][j], v[i]+dp[i-1][j-w[i]]);	
					}
				}
			}
		}
		System.out.println(dp[n][m]);
	}
}

优化（二维转一维）

思路：

1.在二维数组赋值的过程中， $d p [i] [j]$ 的值只与第 $i - 1$ 层的 $d p$ 值有关，便可以用一维 $d p$ 数组表示每一层在背包容量为 $j$ 时取得的最大价值；

2.在内层循环进行处理时，会用到 $d p [i - 1] [j - w [i]]$ 的值，但是因为内层循环是从小到大的，所以在用到 $d p [i - 1] [j - w [i]]$ 的值时， $d p [j - w [i]]$ 已经表示为第 $i$ 层的值，而不是第 $i - 1$ 层的值，所以内层循环需要从大到小执行；

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int[] w = new int[n+1];
		int[] v = new int[n+1];
		for(int i=1;i<=n;i++){
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
		}
		int[] dp = new int[m+1];
		for(int i=0;i<n+1;i++){
			for(int j=m;j>=w[i];j--){
				dp[j] = Math.max(dp[j],dp[j-w[i]]+v[i]);
			}
		}
		System.out.println(dp[m]);
	}
}

完全背包

题目链接：小明的背包2 - 蓝桥云课 (lanqiao.cn)

思路：

1.基本原理与 $01$ 背包相同；

2.每一件物品都有无限个，其实并不是无限个，因为背包的容量是有限的，即每一件物品的最多数量为 $j / w [i]$ ；

3.放入第 $i$ 件商品后，仍然可以放第 $i$ 件物品，那么剩余体积能带来的最大价值为 $d p [i] [j - w [i]]$ ；

4.状态转移方程为： $d p [i] [j] = M a t h . ma x (d p [i - 1] [j], d p [i] [j - w [i]] + p [i])$ ；

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int v = scan.nextInt();
        int dp[][] = new int[n+1][v+1];
        int w[] = new int[n+1];
        int p[] = new int[n+1];
        for(int i = 1 ; i <=n;i++) {
            w[i] = scan.nextInt();
            p[i] = scan.nextInt();
        }
        for(int i =1; i <= n; i++) {
            for(int j =1; j <=v; j++) {
                if(w[i]<=j) {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-w[i]]+p[i]);//直接考虑还能放多少价值
                }else {
                    dp[i][j]=dp[i-1][j];
                }
            }
        }
        System.out.println(dp[n][v]);
    }
}

多重背包

题目链接：小明的背包3 - 蓝桥云课 (lanqiao.cn)

思路：

1.在 $01$ 背包的基础上增加了每一件物品的数量，并且数量是指定的；

2.多一层循环判断第 $i$ 件物品放多少个，并且不能超过背包容量 $j$ ，如果放入 $k = 0$ 件，即表示不放；

import java.util.*;

public class Main{
    static int n,v;
    static int[] w=new int[1010];
    static int[] c=new int[1010];
    static int[] s=new int[1010];
    static int[][] dp=new int[2020][2020];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        v=sc.nextInt();
        for(int i=1;i<=n;i++) {
            w[i]=sc.nextInt();
            c[i]=sc.nextInt();
            s[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++) {
            for(int j=0;j<=v;j++) {
                for(int k=0;k<=s[i]&&k*w[i]<=j;k++) {
                    dp[i][j]=Math.max(dp[i][j], dp[i-1][j-k*w[i]]+k*c[i]);
                }
            }
        }
        System.out.println(dp[n][v]);
    }
}