最长降序子序列一道航天标准化笔试题

有一无序整数列 X1，X2，... ,Xn。用从该序列中删除若干数字的方法，使剩下的长度为m的序列成为单调递减的序列。注意，不可以改变序列中数字的顺序关系。要求构造算法求得m值为最大的序列，即删除数字最少，结果序列最长的序列。  例如：  

1） 序列       4，8，6 ，5 ，2 ，1，3，2，1   (n=9)     

    删除3个数  （4），8，6，5，（2），（1），3，2，1     

    结果      8，6，5，3，2，1     （m=6)

2） 序列       4，1，3，2，1，8，0，7，6 ，5 ，1   (n=11)          

    结果     8，7，6，5，1     （m=5)                   

              4，3，2，1，0     （m=5)

    备注:序列2为多解的情况.

package src;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Psort {
    private String input;
    private int[] inputInt;
    List list_src=new ArrayList();
    List list_des=new ArrayList();
    List list_src2=new ArrayList();
    List list_des2=new ArrayList();

    public Psort() {
        // TODO 自动生成构造函数存根
        System.out.println("请用中文输入法输入数字序列，用\"，\"隔开");
        input=this.inputFromKeyBoard();
        String[] inputChar=input.split("，");
        inputInt=new int[inputChar.length];
        for(int i=0;i<inputChar.length;i++){
            inputInt[i]=Integer.parseInt(inputChar[i]);
        }
        initLinks();
        AG();
        while(!isOver()){
            list_des2=list_des;
            AG();
        }
        for(int i=0;i<list_des2.size();i++) {
            link link = (link) list_des2.get(i);
            System.out.println("数目："+link.count);
            System.out.println("路径："+link.road);
        }        
    }
    
    public boolean isOver(){
        if(list_src.size()>=1){
            return false;
        }
        return true;
    }
    
    public void AG(){
        list_des=new ArrayList();
        for(int i=0;i<list_src.size();i++){
            for(int j=0;j<list_src2.size();j++){
                link link_i=(link)list_src.get(i);
                link link_j=(link)list_src2.get(j);
                if(link_i.n_value==link_j.p_value&&link_i.n_i!=link_j.n_i&&link_i.n_i<=link_j.p_i){
                    link link_new=new link(link_i.p_value,link_i.p_i,link_j.n_value,link_j.n_i,link_i.count+link_j.count-1,link_i.road);
                    list_des.add(link_new);
                }
            }
        }
        list_src=list_des;
    }
    
    public void initLinks(){
        for(int i=0;i<inputInt.length;i++){
            for(int j=i+1;j<inputInt.length;j++){
                if(inputInt[i]>=inputInt[j]){
                    list_src.add(new link(inputInt[i],i,inputInt[j],j,2,String.valueOf(inputInt[i])));
                }
            }
        }
        list_src2=list_src;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自动生成方法存根
        new Psort();
    }
    
//    键盘输入，返回字符串
    public String inputFromKeyBoard(){
            String str=null;
            try{
                InputStreamReader inputReader;
                BufferedReader bufReader;
                inputReader = new InputStreamReader(System.in);
                bufReader = new BufferedReader(inputReader);
                str = bufReader.readLine();
            }catch(IOException e){
                e.printStackTrace();
            }
            return str;
        }
//    *****************************************************************************

}
class link{
    public int p_value;
    public int p_i;
    public int n_value;
    public int n_i;
    public int count;
    public String road;

    public link(int p_value,int p_i,int n_value,int n_i,int count,String road){
        this.p_value=p_value;
        this.p_i=p_i;
        this.n_value=n_value;
        this.n_i=n_i;
        this.count=count;
        this.road=road+" "+n_value;
    }
}