算法之动态规划

1、背包问题：

package com.arithmetic.dynamic;
//可以使用动态规划来解决背包问题。一个使用动态规划解决背包问题的示例。
//knapSack方法接收背包容量W、物品重量数组wt、物品价值数组val和物品数量n作为参数，返回背包能容纳的最大总价值。
//在动态规划的思想下，创建一个二维数组dp，其中dp[i][w]表示在前i个物品中，容量为w的背包的最大总价值。
//通过两重循环遍历dp数组，根据当前物品与背包容量的关系更新dp数组的值。
//最终返回dp[n][W]即为背包能容纳的最大总价值。

//在main方法中，定义一个例子，背包的容量为50，有三个物品，物品的重量分别是10、20、30，价值分别是60、100、120，打印出背包能容纳的最大总价值。
//背包问题可以应用于很多实际的决策和优化场景，例如资源分配、投资决策、库存管理等。
//通过合理地建模和求解背包问题，能够帮助进行决策分析和优化操作，提高资源利用效率和经济效益。

public class KnapsackDemo {
    public static int knapSack(int W, int wt[], int val[], int n) {
        int[][] dp = new int[n + 1][W + 1];

        for (int i = 0; i <= n; i++) {
            for (int w = 0; w <= W; w++) {
                if (i == 0 || w == 0) {
                    dp[i][w] = 0;
                } else if (wt[i - 1] <= w) {
                    dp[i][w] = Math.max(val[i - 1] + dp[i - 1][w - wt[i - 1]], dp[i - 1][w]);
                } else {
                    dp[i][w] = dp[i - 1][w];
                }
            }
        }

        return dp[n][W];
    }

    public static void main(String[] args) {
        int val[] = new int[] { 60, 100, 120 };
        int wt[] = new int[] { 10, 20, 30 };
        int W = 50;
        int n = val.length;
        System.out.println(knapSack(W, wt, val, n));
    }
}

2、最长公共子序列：

package com.arithmetic.dynamic;
//lcs方法接收两个字符串s1和s2作为参数，返回它们的最长公共子序列的长度。
//在动态规划的思想下，创建一个二维数组dp，其中dp[i][j]表示字符串s1的前i个字符和字符串s2的前j个字符的最长公共子序列的长度。
//通过两重循环遍历dp数组，根据当前字符与前一个字符的关系更新dp数组的值。
//最终返回dp[m][n]即为最长公共子序列的长度，其中m和n分别为字符串s1和s2的长度。

//在main方法中，定义一个例子，字符串s1为"ABCDGH"，字符串s2为"AEDFHR"，打印出最长公共子序列的长度。

//实际应用场景：
//编辑距离计算：LCS 可以用来计算两个文本（字符串）之间的差异程度，即两个文本之间需要进行多少次编辑（插入、删除、替换）操作才能完全匹配。
//在文本相似度比较、拼写检查、论文相似性检测等应用中都能用到编辑距离计算。
//DNA 序列比对：在生物信息学中，LCS 被广泛应用于 DNA 序列字符串比对。
//通过计算两条 DNA 序列的最长公共子序列，可以找出它们的共同基因或相似基因片段。
//版本控制系统：版本控制系统（如 Git）使用 LCS 算法来比较不同版本的文件，在合并冲突时找出两个版本之间的不同之处，并进行相应的合并操作。
//自然语言处理：LCS 可以用于自然语言处理领域的语义相似性计算，通过比较两个文本序列之间的最长公共子序列，可以评估它们的文本相似度。
//视频/音频匹配：LCS 算法可以用于视频或音频信号的匹配任务。
//例如，可以通过比较视频中相邻帧之间的最长公共子序列，来检测视频中的重复片段或相似片段。

public class LongestCommonSubsequenceDemo {
	
    public static int lcs(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++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0) {
                    dp[i][j] = 0;
                } else 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];
    }

    public static void main(String[] args) {
        String s1 = "ABCDGH";
        String s2 = "AEDFHR";
        System.out.println("Longest Common Subsequence Length: " + lcs(s1, s2));
    }
}

3、最长递增子序列：

package com.arithmetic.dynamic;
import java.util.Arrays;
//lis方法接收一个整数数组nums作为参数，返回数组中最长递增子序列的长度。
//在动态规划的思想下，创建一个一维数组dp，其中dp[i]表示以第i个元素结尾的最长递增子序列的长度。
//初始化dp数组的所有元素为1，表示每个元素自己就是一个递增子序列。
//然后使用两重循环，外层循环遍历每个元素，内层循环遍历当前元素前面的所有元素。
//如果当前元素大于前面的元素，表示可以将当前元素加入到以前面元素为结尾的递增子序列中，此时更新dp[i]的值为前面元素的递增子序列长度加1。
//最后遍历整个dp数组，找出其中的最大值，即为最长递增子序列的长度。
//在main方法中，定义了一个例子，数组nums为{10, 9, 2, 5, 3, 7, 101, 18}，打印出最长递增子序列的长度。

//实际应用：
//任务安排：假设有一组任务需要按照某种顺序执行，并且每个任务都有一个执行时间。我们希望找到执行时间最长的任务序列，使得任务的执行时间递增。
//例如，假设有以下任务和执行时间：
//任务A：执行时间5
//任务B：执行时间3
//任务C：执行时间7
//任务D：执行时间2
//最长递增子序列为任务B和任务D，执行时间为5，表示按照这个顺序执行任务B和任务D，共需时5个单位时间。
//网络传输路由：在计算机网络中，数据包需要通过多个节点进行传输，选择最佳的传输路由对于提高网络传输性能非常重要。可以通过最长递增子序列来确定传输数据包的最佳路径。
//例如，假设有一些网络节点，每个节点有一个权重表示其传输能力。我们希望找到从起点到终点的路径，使得路径上的节点权重递增。
//数字货币交易：在数字货币交易中，交易日志记录了不同时间点的货币价格。通过找到最长递增子序列，可以确定具有潜在增长趋势的货币，并作出相应的交易决策。
//最长递增子序列在实际应用中具有广泛的应用，包括股票交易、DNA序列比对、任务安排、网络传输路由和数字货币交易等。
public class LongestIncreasingSubsequenceDemo {
    public static int lis(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }

        int max = 0;
        for (int i = 0; i < n; i++) {
            max = Math.max(max, dp[i]);
        }

        return max;
    }

    public static void main(String[] args) {
    	
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        
        System.out.println("Longest Increasing Subsequence Length: " + lis(nums));
    }
}