技术领域：深度解析动态规划的魅力

见解分享

2024-02-19 06:58:15

在算法的世界里，动态规划是一个举足轻重的存在，它以其独到的思维方式和广泛的应用场景，为解决复杂问题提供了强大的工具。在技术领域，动态规划技术可谓是如虎添翼，赋能开发者更高效地解决各种难题。

探索动态规划的奥妙

动态规划是一种自底向上的求解方法，它将复杂的问题分解成更小的子问题，逐步求解并存储结果，以避免重复计算。其核心思想是：将问题的解法划分为相对独立的子问题，并利用这些子问题的解来获得原问题的解。

算法中常用的动态规划技术有：

斐波那契数列： 计算第n个斐波那契数
爬楼梯： 计算爬到第n层台阶有多少种方式
最小花费爬楼梯： 计算爬到第n层台阶并花费最少硬币的方法
打家劫舍： 小偷闯入一排房子，每个房子都有价值，求小偷最多能偷取多少价值的物品，但相邻的房子不能同时被偷取
最长公共子序列： 给定两个序列，求两个序列的最长公共子序列

代码实现：Java与Kotlin

Java：

public class DynamicProgramming {

    public static int Fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return Fibonacci(n - 1) + Fibonacci(n - 2);
    }

    public static int ClimbStairs(int n) {
        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];
        }
        return dp[n];
    }

    public static int MinCostClimbStairs(int[] cost, int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[n];
    }

    public static int Rob(int[] nums, int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = nums[0];
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
        }
        return dp[n];
    }

    public static int LongestCommonSubsequence(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = 0;
        }
        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];
    }

}

Kotlin：

class DynamicProgramming {

    companion object {

        fun Fibonacci(n: Int): Int {
            if (n <= 1) {
                return n
            }
            return Fibonacci(n - 1) + Fibonacci(n - 2)
        }

        fun ClimbStairs(n: Int): Int {
            val dp = IntArray(n + 1)
            dp[0] = 1
            dp[1] = 1
            for (i in 2..n) {
                dp[i] = dp[i - 1] + dp[i - 2]
            }
            return dp[n]
        }

        fun MinCostClimbStairs(cost: IntArray, n: Int): Int {
            val dp = IntArray(n + 1)
            dp[0] = 0
            dp[1] = 0
            for (i in 2..n) {
                dp[i] = minOf(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
            }
            return dp[n]
        }

        fun Rob(nums: IntArray, n: Int): Int {
            val dp = IntArray(n + 1)
            dp[0] = 0
            dp[1] = nums[0]
            for (i in 2..n) {
                dp[i] = maxOf(dp[i - 1], dp[i - 2] + nums[i - 1])
            }
            return dp[n]
        }

        fun LongestCommonSubsequence(s1: String, s2: String): Int {
            val m = s1.length
            val n = s2.length
            val dp = Array(m + 1) { IntArray(n + 1) }
            for (i in 0..m) {
                dp[i][0] = 0
            }
            for (j in 0..n) {
                dp[0][j] = 0
            }
            for (i in 1..m) {
                for (j in 1..n) {
                    if (s1[i - 1] == s2[j - 1]) {
                        dp[i][j] = dp[i - 1][j - 1] + 1
                    } else {
                        dp[i][j] = maxOf(dp[i - 1][j], dp[i][j - 1])
                    }
                }
            }
            return dp[m][n]
        }

    }

}