动态规划求最长子序列

public static void longestStr(){
        Scanner in = new Scanner(System.in);
        int nextInt = in.nextInt();
        int[] s = new int[nextInt];
        for (int i = 0; i < nextInt; i++) {
            s[i] = in.nextInt();
        }

        //直接计算出每一个i开始时，最长的子序列，然后从第一个开始循环，遇到比它大的，直接拿已保存的子序列拼接
        //从最后开始计算，
        //核心思想就是省去重复的计算，只计算一次
        HashMap<Integer,List<Integer>> map = new HashMap<>();
        int max_len = 0;
        int max_index= s.length-1;//最长子序列对应的在map中的位置
        List<Integer> maxList;
        for (int i = s.length-1; i >= 0 ; i--) {
            List<Integer> list = new ArrayList<>();
            if (i == s.length-1) {
                list.add(s[i]);
                map.put(i,list);
                max_len = 1;
                continue;
            }
            for (int j = i+1; j < s.length; j++) {
                if (s[i]<s[j]){
                    List<Integer> list1 = map.get(j);
                    //list1.add(s[i]);
                    if (list1.size()+1>max_len){
                        List<Integer> list2 = new ArrayList<>();
                        for (Integer ss : list1) {
                            list2.add(ss);
                        }
                        list2.add(s[i]);
                        map.put(i,list2);
                        max_index = i;
                        max_len = list1.size();
                    }
                }
            }
            //到这里，s[i]还未存储到map中，说明它后面没有可拼接的子序列，就以它本身放到map中
            if (map.get(i)==null){
                List<Integer> list1 = new ArrayList<>();
                list1.add(s[i]);
                map.put(i,list1);
            }
        }
        //根据max_index查到对应list，再倒序输出
        List<Integer> l = map.get(max_index);
        for (int i = l.size()-1; i >=0 ; i--) {
            if (i==0){
                System.out.print(l.get(i));
                continue;
            }
            System.out.print(l.get(i)+" ");
        }

    }