Java版高级数据结构算法 - 动态规划算法（解决常见笔试面试题）

最新推荐文章于 2024-07-25 10:54:19 发布
最新推荐文章于 2024-07-25 10:54:19 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： Java数据结构算法 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiangweiyuan/article/details/90056459
版权

知识的学习在于点滴记录，坚持不懈；知识的学习要有深度和广度，不能只流于表面，坐井观天；知识要善于总结，不仅能够理解，更知道如何表达！

文章目录

动态规划算法思想

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行的解，每一个解都对应于一个值，我们希望找到具有最优值的解。

动态规划算法和分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

但是与分治法不同的是，适用于动态规划算法求解的问题，经分解得到的子问题往往不是互相独立的，即下一个子阶段的求解是建立在上一个子阶段的解的基础上进一步的求解，如果这样的问题采用分治法求解时，有些子问题被重复计算了很多次，效率比较低！

如果能够保存已解决的子问题的结果，而在需要的时候再找出子问题已求得的答案，就可以避免大量重复计算，从而得到多项式的时间算法，这要比用子集树解决同样问题（比如0-1背包）所花费的指数时间要好的多！。

但是这也不是说动态规划就一定比子集树解决问题的效率高，子集树解决问题的时间复杂度虽然是指数级别的 O ( 2 n ) O(2^n) O(2n)，但是通过添加适当的剪枝操作，可以大大提高子集树的遍历效率。

我们可以用一个表来记录所有已解的子问题的答案，不管该子问题以后是否被用到，只要它被计算过，就将其计算结果填入表中，这就是动态规划算法的基本思路，虽然具体的问题采用动态规划算法的形式多种多样，但它们都具有相同的填表格式。

动态规划基本步骤

1.找出问题最优解的性质，并刻画其结构特征（找“状态”）
2.递归的定义最优值 （找“状态转移方程”）
3.以自底向上的方式计算出问题的最优值
4.根据计算最优值时得到的信息，构造最优解

核心就是找出问题的“状态”以及”状态转移方程“。

硬币问题

问题描述：有面值1，3，5分的硬币，问达到指定价值，最少需要几个硬币？
状态dp(i)表示i价值需要的最少的硬币数量；状态转换方程：dp(i) = min{dp(i-vj) + 1}，其中 i >= vj，i表示价值，vj表示第j个硬币的价值，代码如下：

public static void main(String[] args) {
    /**
     * dp(i)：表示i价值需要的最少的硬币数量
     * dp(i) = min{dp(i-vj) + 1}; 其中i-vj>=0，vj表示第j个硬币的面值
     */
    int[] ar = {1,3,5};
    int val = 11;
    int[] dp = new int[val+1];

    for (int i = 1; i <= val; i++) {
        dp[i] = i; // 先取一个最大值，假设放的都是面额为1的硬币，硬币数量最多
        for (int j = 0; j < ar.length; j++) {
            if(i >= ar[j] && (dp[i-ar[j]] + 1) < dp[i]){
                dp[i] = dp[i-ar[j]] + 1;
            }
        }
    }

    System.out.println(Arrays.toString(dp));
    System.out.println(dp[val]);
}

最大字段和问题

问题描述：给定n个整数，可能为负数组成的序列a[1]，a[2]，…，a[n]，求该序列如a[i]+a[i+1]+…+a[j]的字段和的最大值，当所给的整数均为负数时定义字段和为0。该问题用动态规划算法求解，状态dp[i]表示以第i个元素结尾的最大字段和，状态转换方程是：d[i] = max{a[i], d[i-1]+a[i]} ，代码如下：

public class DPMaxChildSegmentSum {
    public static void main(String[] args) {
        int[] ar = {12,-16,8,-5,9,-12,10} ;
        int[] dp = new int[ar.length];
        int sum = maxSegmentSum(ar, dp);
        System.out.println(Arrays.toString(dp));
        System.out.println(sum);
    }

    private static int maxSegmentSum(int[] ar, int[] dp) {
        dp[0] = ar[0] >= 0? ar[0] : 0;
        int maxSum = dp[0];

        for(int i=1; i<ar.length; ++i){
            dp[i] = dp[i-1] + ar[i];
            if(dp[i] < 0){
                dp[i] = 0;
            }

            if(maxSum < dp[i]){
                maxSum = dp[i];
            }
        }

        return maxSum;
    }
}

求LIS最长非降子序列问题

该问题采用动态规划算法解决，其状态dp[i]表示以第i个元素结尾的最长非降子序列的长度值，状态转移方程是：dp(i) = max{1, dp(j)+1} 其中j<i 而且 A[j]<=A[i]，代码如下：

public class DPLISLength {
    public static void main(String[] args) {
        String str = "asdfiez";
        int[] dp = new int[str.length()];
        int length = LIS(str, str.length(), dp);
        System.out.println("LISLength:" + length);
    }

    private static int LIS(String str, int length, int[] dp) {
        int maxlen = 0;

        for (int i = 0; i < length; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if(str.charAt(j) < str.charAt(i)
                        && dp[j]+1 > dp[i]){
                    dp[i] = dp[j] + 1;
                }
            }

            if(maxlen < dp[i]){
                maxlen = dp[i];
            }
        }

        return maxlen;
    }
}

求LCS最长公共子序列问题

/**
 *  描述: 求两个序列的最长公共子序列问题
 *  有两个序列
 *  Xn = {X1, X2, X3, ... , Xn}
 *  Yn = {Y1, Y2, Y3, ... , Yn}
 * 
 *  以上两个序列的最长公共子序列为
 *  1.如果Xn == Yn，那么
 *  LCS = LCS{[X1...Xn-1], [Y1...Yn-1]} + Xn
 * 
 *  2.如果Xn != Yn，那么
 *  LCS = LCS{[X1...Xn], [Y1...Yn-1]}
 *  LCS = LCS{[X1...Xn-1], [Y1...Yn]}
 * @param args
 */
public static void main(String[] args) {
    String str1 = "abcsafsa";
    String str2 = "cafa";
    int length = LCS(str1, str2, str1.length(), str2.length());
    System.out.println("length1:" + length);
}

/**
 * 非递归求解LCS问题
 * @param str1
 * @param str2
 * @param i
 * @param j
 * @return
 */
private static int LCS(String str1, String str2, int i, int j) {
    int maxlen = 0;
    // 用该数组记录动态规划问题求解中，重复子问题的解，避免重复计算，提高算法效率
    int[][] dp = new int[i+1][j+1];
    for(int m=1; m <= i; ++m){
        for(int n=1; n <= j; ++n){
            if(str1.charAt(m-1) == str2.charAt(n-1)){
                dp[m][n] = dp[m-1][n-1] + 1;
            } else {
                dp[m][n] = Math.max(dp[m-1][n], dp[m][n-1]);
            }

            if(maxlen < dp[m][n]){
                maxlen = dp[m][n];
            }
        }
    }
    return maxlen;
}

上面的代码只是打印出最长公共子序列的长度，如果想要打印最长公共子序列的元素，则要记录dp表的走向，然后用回溯法进行元素打印，代码如下：

/**
 *  描述: 求两个序列的最长公共子序列问题
 *  有两个序列
 *  Xn = {X1, X2, X3, ... , Xn}
 *  Yn = {Y1, Y2, Y3, ... , Yn}
 *
 *  以上两个序列的最长公共子序列为
 *  1.如果Xn == Yn，那么
 *  LCS = LCS{[X1...Xn-1], [Y1...Yn-1]} + Xn
 *
 *  2.如果Xn != Yn，那么
 *  LCS = LCS{[X1...Xn], [Y1...Yn-1]}
 *  LCS = LCS{[X1...Xn-1], [Y1...Yn]}
 * @param args
 */
public static void main(String[] args) {
    String str1 = "abcsafsa";
    String str2 = "cafa";
    // 辅助数组，记录LCS元素的走向
    int[][] arr = new int[str1.length()+1][str2.length()+1];
    int length = LCS(str1, str2, str1.length(), str2.length(), arr);
    System.out.println("length1:" + length);

    backstrace(str1, str1.length(), str2.length(), arr);
}

/**
 * 非递归求解LCS问题
 * @param str1
 * @param str2
 * @param i
 * @param j
 * @param arr
 * @return
 */
private static int LCS(String str1, String str2, int i, int j, int[][] arr) {
    int maxlen = 0;
    // 用该数组记录动态规划问题求解中，重复子问题的解，避免重复计算，提高算法效率
    int[][] dp = new int[i+1][j+1];
    for(int m=1; m <= i; ++m){
        for(int n=1; n <= j; ++n){
            if(str1.charAt(m-1) == str2.charAt(n-1)){
                dp[m][n] = dp[m-1][n-1] + 1;
                arr[m][n] = 1;
            } else {
                if(dp[m-1][n] > dp[m][n-1]){
                    dp[m][n] = dp[m-1][n];
                    arr[m][n] = 2;
                } else {
                    dp[m][n] = dp[m][n-1];
        		    arr[m][n] = 3;
                }
            }

            if(maxlen < dp[m][n]){
                maxlen = dp[m][n];
            }
        }
    }
    return maxlen;
}

/**
 * 输出最长LCS子序列内容
 * @param str1
 * @param length
 * @param length1
 * @param arr
 */
private static void backstrace(String str1, int length,
                               int length1, int[][] arr) {
    if(length <= 0 || length1 <= 0){
        return;
    }

    if(arr[length][length1] == 1){
        backstrace(str1, length-1, length1-1, arr);
        System.out.print(str1.charAt(length-1) + " ");
    } else {
        if(arr[length][length1] == 2){
            backstrace(str1, length-1, length1, arr);
        } else {
            backstrace(str1, length, length1-1, arr);
        }
    }
}

0-1背包问题

/**
 * 描述: 动态规划求解0-1背包问题
 *
 * 先处理上面表中最后一行dp(n, j)
 * j < wn   0
 * j >= wn  vn
 * 再处理其它行的情况 dp(i, j)
 * 0<= j < wi   dp(i+1, j)
 * j >= wi     max{dp(i+1, j), dp(i+1, j-wi)+vi}
 *
 * @Author shilei
 * @Date 5/1
 */
public class DP01Package {
    public static void main(String[] args) {
        int[] w = {8,6,4,2,5};
        int[] v = {6,4,7,8,6};
        int c = 20;
        int[][] dp = new int[w.length][c+1];
        // 动态规划求解0-1背包问题
        func(w, v, c, dp);
        // 打印最优解的值和选择的物品
        int[] x = new int[w.length];
        backtrace(w, v, c, dp, x);
    }

    /**
     * 回溯打印选择的物品
     * @param w
     * @param v
     * @param c
     * @param dp
     * @param x
     */
    private static void backtrace(int[] w, int[] v, int c, int[][] dp, int[] x) {
        int bestv = 0;

        for(int i=0; i<w.length-1; ++i){
            if(dp[i][c] == dp[i+1][c]){
                x[i] = 0;
            } else {
                x[i] = 1;
                bestv += v[i];
                c -= w[i];
            }
        }

        // 处理第n个物品
        if(dp[w.length-1][c] > 0){
            bestv += v[w.length-1];
            x[w.length-1] = 1;
        }

        System.out.println(bestv);
        System.out.println(Arrays.toString(x));
    }

    /**
     * 求解0-1背包价值最优的物品选择
     * @param w
     * @param v
     * @param c
     * @param dp
     */
    private static void func(int[] w, int[] v, int c, int[][] dp) {
        int n = w.length - 1;

        // 先处理dp表中最后一行 dp(n, j)
        for(int j=1; j<=c; ++j){
            if(j < w[n]){
                dp[n][j] = 0;
            } else {
                dp[n][j] = v[n];
            }
        }

        // 处理其它n-1行的最优解
        for(int i=n-1; i>=0; --i){
            for(int j=1; j<=c; ++j){
                if(j < w[i]){
                    dp[i][j] = dp[i+1][j];
                } else {
                    dp[i][j] = Math.max(dp[i+1][j], dp[i+1][j-w[i]]+v[i]);
                }
            }
        }
    }
}

数字三角形问题

数字三角形问题：一个数字三角宝塔，规定从最顶层走到最底层，每一步可沿垂直向下，左斜线向下，或右斜线向下走，求解从最顶层走到最底层的一条路径，使得沿着该路径所经过的数字的总和最大，输出最大值。

样例输入：
第一行是数塔层数N(1<=N<=100)。
第二行起，从一个数字按数塔图形依次递增，共有N层。
5
13
11 8
12 7 26
6 14 15 8
12 7 13 24 11
样例输出：86

这个问题可以自底向上递归进行求解（但是注意，很多子问题被重复求解，效率不好！），代码如下：

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    System.out.println("输入三角形数组的层数:");
    int n = in.nextInt();
    System.out.println("输入三角数组:");
    int[][] arr = new int[n+1][n+1];
    for(int i=1; i<=n; ++i){
        for (int j = 1; j <= i; j++) {
            arr[i][j] = in.nextInt();
        }
    }

    int max = findMaxPath(arr, 1, 1, n);
    System.out.println("max value:" + max);
}

private static int findMaxPath(int[][] arr, int i, int j, int n) {
    if(i == n || j == 0){
        return arr[i][j];
    } else {
        return Math.max(Math.max(findMaxPath(arr, i+1, j-1, n), findMaxPath(arr, i+1, j, n))
                , findMaxPath(arr, i+1, j+1, n)) + arr[i][j];
    }
}

上面的递归存在子问题被重复求解（这不刚好是动态规划能解决的问题的要素之一吗？）这个问题很容易换个角度思考一下，在值最大的数字路径上，也就是最优路径上的每一个数字开始的向下的路径也是该数字到最后一层的最优路径，符号动态规划的第二个基本要素（最优子结构原理），所以用动态规划解决该问题非常合适。

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    System.out.println("输入三角形数组的层数:");
    int n = in.nextInt();
    System.out.println("输入三角数组:");
    int[][] arr = new int[n+1][n+1];
    for(int i=1; i<=n; ++i){
        for (int j = 1; j <= i; j++) {
            arr[i][j] = in.nextInt();
        }
    }

    // dp数组用来记录子问题的解
    int[][] dp = new int[n+1][n+1];

    int max = findMaxPath(arr, 1, 1, n, dp);
    System.out.println("max value:" + max);
}

private static int findMaxPath(int[][] arr, int i, int j, int n, int[][] dp) {
    if (i == n || j == 0){
        dp[i][j] = arr[i][j];
        return dp[i][j];
    } else {
        if(dp[i][j] > 0) { // 如果子问题的解已经计算过，直接返回
            return dp[i][j];
        }

        dp[i][j] = Math.max(Math.max(findMaxPath(arr, i+1, j-1, n, dp)
                , findMaxPath(arr, i+1, j, n, dp))
                , findMaxPath(arr, i+1, j+1, n, dp)) + arr[i][j];
        return dp[i][j];
    }
}

输出结果如下：

输入三角形数组的层数:
5
输入三角数组:
13
11 8
12 7 26
6 14 15 8
12 7 13 24 11
max value:86
大秦坑王
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java笔试--动态规划
软件工程
10-15 113
相关题目： 面试题 17.26. 稀疏相似度 稀疏相似度： 通过暴力循环时求解发现，复杂度达到了O(N^3),运行超时。所以可以在此基础上求出每一个元素出现的所有文件的编号(也就是数组的行号)。在同时可以记录出任意两个文件的公共元素的数量(通过稀疏矩阵的方式活着hashMap的方式) class Solution { public List<String> computeSimilarities(int[][] docs) { //采用包理的方法会出现运行.
《剑指offer》刷题——【动态规划与贪婪算法】面试题14：剪绳子（java实现）
HW_870754395的博客
04-27 821
《剑指offer》刷题——【动态规划与贪婪算法】面试题14：剪绳子一、动态规划1. 应用动态规划求解的问题的特点二、贪婪算法三、题目描述四、解题思路（一）动态规划1. 思路分析2. 代码实现（动态规划）3. 时间复杂度O(n^2)（二）贪婪算法1. 思路分析2. 代码实现3. 时间复杂度O(1) 一、动态规划 1. 应用动态规划求解的问题的特点 求一个问题的最优解（最大值、最小值） 该问题能否分...
JAVA-高频面试题汇总:动态规划
Apollo的博客
12-30 1万+
JAVA-动态规划高频面试题汇总 小编统计出了动态规划中常考题,附上了题目出处以及最优解法.接下来还会进行其他模块的总结,有一起在准备暑期实习的JAVA软开伙伴可以一起交流! 1.打家劫舍 class Solution { public int rob(int[] nums) { if(nums.length==0) return 0; //长度为0和1时要考虑,否则后面会越界 if(nums.length==1) return nums[0];
动态规划有哪些经典题目？
最新发布
Good_tea_h的博客
07-25 1206
设rn为长度为n的钢条能获得的最大收益，则rn就是我们要找的最优解。
动态规划笔试题 java_笔试算法题（44）：动态规划（Dynamic Programming）
weixin_31458015的博客
03-02 216
DP主要用于解决包含重叠子问题(OverlappingSubproblems)的最优化问题，其基本策略是将原问题分解为相似的子问题，通过求解并保存最简单子问题的解，然后逐步合并成为原问题的解，由于需要查询子问题的解，所以需要一个表格记录子问题的解；DP仅适用于最优子结构问题(OptimalSubstructure)，也就是局部最优解相当于(或者近似于)全局最优解；对于原问题而言，当递归地自顶向下对...
基础算法系列总结：动态规划(解公司外包成本问题）
weixin_34415923的博客
05-17 140
理论辅助： 动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分...
常见数据结构与算法笔试面试题大集合
09-12
这份“常见数据结构与算法笔试面试题大集合”涵盖了这一领域的核心概念，旨在帮助求职者更好地准备相关考试和面试。 1. **数组**：数组是最基础的数据结构，它提供了一种在内存中存储和访问固定数量元素的方式。...
数据结构算法设计笔试面试题100题内含C语言解析
12-17
本资源“数据结构算法设计笔试面试题100题内含C语言解析”是针对求职者或学习者准备的一个宝贵资料集，涵盖了多个经典的数据结构和算法题目，旨在提升解题能力和理论理解。 一、二元查找树（Binary Search Tree, ...
leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
10-03
该压缩包文件“leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip”显然是针对Java开发者，特别是那些准备面试或希望通过LeetCode提升编程技能的人。文件内容可能包括对LeetCode中常见...
[持续更新]leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
包含Java基础，编码规范，笔试题，面试技巧，数据结构及算法，架构设计等等.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
java高级算法
07-03
高级算法归并，有需要的自己可以下载一些。文件里面是网盘的地址和密码。
高级java笔试题-algorithm:算法
06-03
高级java笔试题 算法学习 这个专栏是Hollis知识星球的朋友们练习算法的地方 欢迎广大网友参与分享算法学习经验 项目目前分为两部分 solutions 目录 算法题解，格式是 md 格式文件，方便阅读 包括 算法平台的题解，如 Leetcode 等 算法书籍的题解，如 《剑指 Offer》 codes 目录： 数据结构和算法的实现代码 包括 各类网络公开课的代码 各类算法书籍的代码 备注 本项目选取的资源都来自官方公开免费资源 本项目所有内容不做商业用途 本项目大部分代码由贡献者自己编写，如有引用则注明出处 学习方式 1. 面试刷题 适合短期面试突击或日常刷题练手 LeetCode： 牛客网： 2. 基础知识 适合从零开始真正学习和掌握数据结构和算法知识 网络公开课 1) 数据结构与算法基础-java版（罗召勇） 访问地址： 2) 尚硅谷Java数据结构与java算法（Java数据结构与算法） 访问地址 笔记 一、数据结构与算法基础-java版（罗召勇） 本课程为 DT 课堂颜群发布在 Bilibili 上的免费视频 《数据结构与算法基础-java版（罗召勇）》 本项目中实现代码
动态规划算法经典例题
05-16
一些动态规划，最新最典型的算法！如，背包问题，钢管切割问题，最长子序列问题等等。
java算法面试题(JAVA高级面试题)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-10 133
java分页算法有哪些？ 两个Vector，一个为储存查询所有记录的totalV，另一个储存当前页的记录currentPageV； 总的记录数：int totalSize = totalV。getSize()； 每页显示的记录数：int countPerPage； 总页数：int totalPageNum...
面试准备------动态规划问题
一只小包子的博客
02-19 906
动态规划 1. Coin Change 问题： 输入一组硬币值 以及需要兑换的总数 输出可兑换的最少硬币数量 不可兑换输出-1 示例： Input: coins = [1, 2, 5], amount = 11 Output: 3 Explanation: 11 = 5 + 5 + 1 解析： 构造一个dp数组 长度为amount+1 每个位置上存放当前amount 能够兑换的最少的硬币数量...
JAVA之——经典算法50题
热门推荐
冰河的专栏
04-08 9万+
转载请注明出处:http://blog.csdn.net/l1028386804/article/details/51097928/******************************************************************************** @author liuyazhuang &lt;1028386804@qq.com&gt;********...
Java中高级核心知识全面解析(3)，美团Java面试算法题
m0_60635084的博客
08-31 158
主服务器 需要将自己生成的 RDB 文件 发送给从服务器，这个发送操作会 消耗 主服务器 大量的网络资源 (带宽和流量)，并对主服务器响应命令请求的时间产生影响； 接收到 RDB 文件的 从服务器 需要载入主服务器发来的 RBD 文件，并且在载入期间，从服务器会因为阻塞而没办法处理命令请求； 特别是当出现 断线重复制 的情况是时，为了让从服务器补足断线时确实的那一小部分数据，却要执行一次如此耗资源的 SYNC&nb.
经典Java高级算法笔试题-动力节点
weixin_49543720的博客
10-26 251
题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ //这是一个菲波拉契数列问题 publicclasstest01{ publicstaticvoidmain(String[]args){ intf1=1,f2=1,f; intM=30; System.out.println(1); System.out.println(2); for(inti=3;i<M;i++){ f=f2; f2=f1+f2;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值