一些动态规划的经典问题（背包问题，最长公共子序列）

一些动态规划的经典问题（0-1背包问题，最长公共子序列）

一、动态规划简述

动态规划特性

（1） 最优子结构 动态规划的问题具有最优子结构的特性，某个问题的解往往包含着其子问题的最优解。问题的最优子结构性质是该问题可用动态规划算法求解的显著特征；
（2） 重叠子问题 动态规划将问题分解成若干的子问题，但是分解之后的子问题往往不是独立的，往往都是互相关联的，某个子问题的解可能需要另一个子问题的解。用分治法可能这些子问题会被重复计算多次，如用分治法解决斐波那契数列的时候，子问题被重复计算多次。而动态规划能够保存已解决子问题的最优解，避免了重复计算子问题。

二、0-1背包问题

2.1 问题描述

有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。

2.2 问题分析

在本次0-1背包问题，采用的是动态规划求解，我们把问题划分成了一个个子问题。可以把问题简化成如下表格。

i/j	0	1	2	3	4	5	6	7	8
0	0	0	0	0	0	0	0	0	0
1	0
2	0
3	0
4	0
5	0

可见问题可以分解为成若干个子问题，可以分解为1、2、3、…、8个物品装到背包大小为1、2、3、4、5、…、8并得到这些子问题的最优解，最终得到问题的最优解。
所谓0-1背包问题，表示每一个物品只有一个，要么装入，要么不装入。如果要装入这件物品，需考虑其背包剩余空间是否足够，并且也需要考虑装了这件物品的总价值高还是不装这件物品的总价值高，如果装了这件物品的总价值高，则选择装入，若没有，则选择不装入。式子如下：
如果背包剩余空间装不下第i件物品，则选择不装第i件物品，式子如下：
bestValue[i][j] = bestValue[i-1][j]
如果剩余空间足够装，则式子如下：

2.3 Java代码复现

mport java.util.Scanner;

public class pack {
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int m,n;        
        System.out.println("请输入你的物品个数和背包大小:");
        m = input.nextInt();n = input.nextInt();
        int[] w = new int[m+1];int[] v =new int[m+1];
        for(int i = 1;i<=m;i++)
        {
            w[i] = input.nextInt();//每件物品所占背包空间大小
            v[i] = input.nextInt();//每件物品具有的价值大小
        }
        input.close();
        int[][] bestValue = new int[m+1][n+1];//每个子问题的最优解，[i][j]代表有i件物品，装入j个大小的背包的最优解。
        for(int i = 0;i <= m;i++)
        {
            bestValue[i][0]=0;//初始化
        }
        for(int i = 0;i <= n;i++)
        {
            bestValue[0][i]=0;//初始化
        }
        for(int i = 1;i <= m;i++)
        {
            for(int j =1;j<= n;j++)
            {
            if(j < w[i])//如果背包装不下第i件物品
            {
                bestValue[i][j] = bestValue[i-1][j];
            }
            else//如果背包装得小第i件物品
            {
                int max = bestValue[i-1][j];//如果不装第i件物品的话
                if((bestValue[i-1][j-w[i]]+v[i])>max)
                max = bestValue[i-1][j-w[i]]+v[i];//装第i件物品
                bestValue[i][j] = max;
            }
            }
        }
        System.out.println(bestValue[m][n]);




    }
    
}

三、最长公共子序列

3.1 问题描述

Problem Description

---

一个数列，如果分别是两个或多个已知数列的子序列，且是所有匹配此条件序列中最长的，则S 称为已知序列的最长公共子序列。

---

Input

---

输入数据有多组，每组有两行 ，每行为一个长度不超过500的数字序列，表示序列X和Y。

---

Sample Input

---

1 3 4 5 6 7 7 8
3 5 7 4 8 6 7 8 2

---

Sample Output

---

5

3.2 问题分析

则式子如下：

3.3 Java代码复现

import java.util.Scanner;
public class Lcs {
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int m,n;
        System.out.println("Please input the number of the first line sequence and the second line sequence:");
        m = input.nextInt();n = input.nextInt();//X和Y数字序列的大小
        int[] first_seq = new int[m + 1];int[] second_seq = new int[n + 1];
        System.out.println("Please input the first line sequence:");
        for(int i = 1;i <=m ;i++)
        {
            first_seq[i] = input.nextInt();
        }
        System.out.println("Please input the second line sequence:");
        for(int j = 1;j <= n;j++)
        {
            second_seq[j] = input.nextInt();
        }
        input.close();
        int[][] lcs = new int[m+1][n+1];//子问题的最长子序列
        for(int i = 1;i <= m;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                if(first_seq[i] == second_seq[j])
                {
                    lcs[i][j] = lcs[i-1][j-1] + 1;//若first_seq[i] == second_seq[j]，则其最优子序列的长度为lcs[i][j] = lcs[i-1][j-1] + 1。
                }
                else
                {
                    lcs[i][j] = lcs[i-1][j];//若first_seq[i] ！= second_seq[j]最优子序列长度为lcs[i][j]=max{lcs[i-1][j],lcs[i][j-1]}

                    if(lcs[i][j] < lcs[i][j-1])
                    {
                        lcs[i][j] = lcs[i][j-1];
                    }

                }
            }
        }
        System.out.println(lcs[m][n]);
        

        


    }
    
}