<pre name="code" class="java">import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Main {
		public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();
		String patternStr = "[\\d\\s]+"; 
		Matcher meq = Pattern.compile(patternStr).matcher(str);
		if(!meq.matches()){
			System.out.println("輸入格式有誤，請重新輸入！");
			System.exit(0);
		 }
		if(str.indexOf(" ")==-1){
			System.out.println(str);
		}else{
			String test[] = str.split(" ");
			int t[] = new int[test.length];
			for(int i=0;i<t.length;i++){
				t[i] = Integer.parseInt(test[i]);
			}
			find(t);
		}
		
		
	}

	  public static void find(int[] a)
	    {
	        int length = a.length;
	        int[] list = new int[length];// 儲存第i個元素之前的最長遞增序列值
	        for (int i = 0; i < length; i++)
	        {
	            list[i] = 1;
	            for (int j = 0; j < i; j++)
	            {
	                if (a[j] < a[i] && list[j] + 1 > list[i])
	                {
	                    list[i] = list[j] + 1;
	                }
	            }
	        }
	        int max = list[0];

	        for (int i = 0; i < length; i++)
	        {
	            if (list[i] > max)
	            {
	                max = list[i];
	            }
	        }
		System.out.println("最長子序列長度為："+max);
//因為得到的list值為各個子序列的最大增長子序列值，所以max遞減，當list值與max相等時
//原陣列該下標處的值即為所求子序列值
	        int res[] = new int[max];
	     System.out.println("最長子序列為：");
		for (int i = length-1; i >= 0; i--) { 
			if (list[i] == max)
				 {
 					res[max-1] = a[i];
				 	max--; 
				}
		 }
		 for (int i = 0; i <res.length; i++)
		 {
			 System.out.print(res[i]+" ");
		 }
		 }
	}
 

一組測試資料下面為測試資料

1 5 8 3 6 7 2 9

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

35 36 39 3 15 27 6 42 

下面為輸出的最長子序列

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

3 15 27 42

根據傳統的lcs演算法求得一組list為各個下標處的最長子序列長度，

以第一組測試資料為例， 1 5 8 3 6 7 2 9

求得的子序列長度陣列為[1, 2, 3, 2, 3, 4, 2, 5]，可以看出長度一次遞增，我們只需順序遞減，求得遞減的下標，即該數組裡5 4 3 2 1 的下標，7 5 4 3 0，

再取原陣列這些下標處的值，就可求得最長子序列陣列了，即1 3 6 7 9