Rosalind Java|Longest Increasing Subsequence动态规划算法

Rosalind编程问题之计算集合中最长的递增元素子集。

Longest Increasing Subsequence

Problem：
A subsequence of a permutation is a collection of elements of the permutation in the order that they appear. For example, (5, 3, 4) is a subsequence of (5, 1, 3, 4, 2).

A subsequence is increasing if the elements of the subsequence increase, and decreasing if the elements decrease. For example, given the permutation (8, 2, 1, 6, 5, 7, 4, 3, 9), an increasing subsequence is (2, 6, 7, 9), and a decreasing subsequence is (8, 6, 5, 4, 3). You may verify that these two subsequences are as long as possible.

Given: A positive integer n≤10000 followed by a permutation π of length n.
Sample input：

5
5 1 4 2 3

Return: A longest increasing subsequence of π, followed by a longest decreasing subsequence of π.
Sample output：

1 2 3
5 4 2

题目给出了我们一个集合{5,1,4,2,3}。需要我们输出最长的递增子集和最长的递减子集。举个栗子，在该集合中{1,4}就是一个递增子集，在保留元素顺序的前提下，元素大小从左到右依次增大。但是该子集并不是最长递增子集，因为存在子集{1,2,3}有三个元素，而{1,4}仅有两个元素。因此子集{1,2,3}是集合{5,1,4,2,3}的最长递增子集。最长递减子集同理。

暴力穷举法

最简单的思路便是暴力穷举法。我们可以从集合中挨个遍历元素作为第一个元素，并暂时视其为最大值/最小值。如果后面的元素大于此，则将后者假定为最长递增/递减集合的元素纳入该集合，同时更新最大值/最小值。遍历结束后统计此时假定的最长递增集合元素数量。以此类推穷举所有递增集合后，我们只需要选取元素数最多的子集，则该子集为最长递增集合。

暴力穷举法要求的计算量庞大，运算时间长。以此题为例，将Rosalind给出的示例数据输入程序可以很快得到最终结果。但是Rosalind给出的实操数据可没有示例数据的数据量那么小。小编拿到的是一个8000多个数字组成的集合。应用此程序需要跑十多分钟，不可能在规定时间内（5min）提交答案，效率低下，因此需要后继算法提升。

小编推荐下面的动态规划法。

动态规划法

动态规划算法需要我们构建一个动态数组用以储存当递增到第i个元素时，组成递增集合所含有的最多元素个数。同时本题还需要建立一个动态集合，用以储存新增的递增/递减元素。当我们用指针i遍历数组permutation时，将指针i所指的元素与i以前的元素可以形成新的数组。如果新增的元素i的值大于i以前的元素j的值，则此时元素i可以与元素j继续构成递增数组/集合。

刚刚构建的动态集合用以储存新增的递增/递减元素，如果元素i的值大于i以前的元素j的值，那么元素i就可以加在元素j的动态集合中，从而形成元素i的动态集合。所形成的最大递增元素数List[i]可以由前i个比i小的List[j]推导，即List[i]=List[j].add[i]。下方示意图展示了动态数组的变化流程，思路上与动态集合的流程一致：

由于Java对于命令行的长度限制，读取输入数据时，我们采用IO流的方法，此方法在先前的博客中有所提及：Java读取空格分隔的数值并输出为数值类型的数组

实现代码如下：

public class Longest_Increasing_Subsequence动态规划 {public static void main(String[] args) {//1.读取数据并进行检查int[] permutationπ = BufferedReader("C:/Users/Administrator/Documents/Downloads/rosalind_lgis.txt");
//        System.out.println(Arrays.toString(permutationπ));//检查数据//2.最长递增序列longestIncrease(permutationπ);//3.最长递减序列longestDecrease(permutationπ);}public static void longestIncrease(int[] permutationπ){//2.建立动态规划数组int[] dp = new int[permutationπ.length];List<List<Integer>> increaseArray = new ArrayList<>();//建一个装集合的集合[学术程稻属]// 初始化increaseArray和dp数组List<Integer> start = new ArrayList<>();start.add(permutationπ[0]);increaseArray.add(start);dp[0] = 1;for (int i = 1; i < permutationπ.length; i++) {List<Integer> Tempincrease = new ArrayList<>();dp[i] = 1;for (int j = 0; j < i; j++) {//最长递增序列if (permutationπ[i] > permutationπ[j]) {dp[i] = Math.max(dp[j] + 1, dp[i]);if (Tempincrease.size()<increaseArray.get(j).size()){Tempincrease = increaseArray.get(j);}}}//！！！！构建临时集合以避免同名变量覆盖之前increaseArray集合中的数据List<Integer> Temp = new ArrayList<>();for (Integer ele : Tempincrease) {Temp.add(ele);}Temp.add(permutationπ[i]);increaseArray.add(Temp);
//            System.out.println(increaseArray);//检查数据}List<Integer> max = new ArrayList<>();for (List<Integer> ele : increaseArray) {if (max.size()<ele.size()){max = ele;}}for (Integer ele : max) {System.out.print(ele+" ");}System.out.println();}public static void longestDecrease(int[] permutationπ){//2.建立动态规划数组int[] dp = new int[permutationπ.length];List<List<Integer>> decreaseArray = new ArrayList<>();//建一个装集合的集合[学术程稻属]// 初始化increaseArray和dp数组List<Integer> start = new ArrayList<>();start.add(permutationπ[0]);decreaseArray.add(start);dp[0] = 1;for (int i = 1; i < permutationπ.length; i++) {List<Integer> Tempdecrease = new ArrayList<>();dp[i] = 1;for (int j = 0; j < i; j++) {//最长递减序列if (permutationπ[i] < permutationπ[j]) {dp[i] = Math.max(dp[j] + 1, dp[i]);if (Tempdecrease.size()<decreaseArray.get(j).size()){Tempdecrease = decreaseArray.get(j);}}}//构建临时集合以避免同名变量覆盖之前increaseArray集合中的数据List<Integer> Temp = new ArrayList<>();for (Integer ele : Tempdecrease) {Temp.add(ele);}Temp.add(permutationπ[i]);decreaseArray.add(Temp);}List<Integer> max = new ArrayList<>();for (List<Integer> ele : decreaseArray) {if (max.size()<ele.size()){max = ele;}}for (Integer ele : max) {System.out.print(ele+" ");}}//读取以空格分隔的数字，并保存到字符串数组中public static int[] BufferedReader(String path) {BufferedReader reader;String[] perm = new String[1];try {reader = new BufferedReader(new FileReader(path));String line = reader.readLine();String line2 = reader.readLine();perm = line2.split("\\s+");reader.close();} catch (IOException e) {e.printStackTrace();}int[] permutationπ = new int[perm.length];for (int i = 0; i < perm.length; i++) {int number = Integer.parseInt(perm[i]);permutationπ[i] = number;}return permutationπ;}
}

几乎在一瞬之间，答案就已经出现！！

改进的空间也是有的，例如本例中的dp数组。本文通过构建ArrayList increaseArray /decreaseArray 实现了动态储存，节省运算资源和储存空间。新建的dp数组用于保存最长递增序列的元素个数，能有助于输出最长递增集合个数，但在本题中对于输出最长递增集合元素没有帮助。故代码中可以省略，有兴趣的小伙伴可以自行尝试精简代码。

感谢大佬EmmettPeng对于动态规划的分析，思路讲解在这篇博客中写的十分详细：【Rosalind】Longest Increasing Subsequence - 动态规划算法（Dynamic Programming）初探.