最大递增(减)子序列

package number;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;

/**
 * @author ycsun E-mail:stevesun521@gmail.com
 * @version 创建时间：2012-10-3 下午4:35:22 类说明
 */
public class ArraysSeq {
    private int[] arr;

    public ArraysSeq(int[] arr) {
        this.arr = arr;
    }

    /**
     * On2复杂度
     */
    public void maxIncreaseSeq() {
        int max = 0;
        int[] lis = new int[arr.length];
        Arrays.fill(lis, 1);
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j] && lis[j] + 1 > lis[i]) {
                    lis[i] = lis[j] + 1;
                    max = max < lis[i] ? lis[i] : max;
                }
            }
        }
        int pre = Integer.MAX_VALUE;
        Stack<Integer> stack = new Stack<Integer>();
        for (int i = lis.length - 1, t = max; i >= 0; i--) {
            if (t == lis[i] && arr[i] < pre) {
                t--;
                pre = arr[i];
                stack.push(arr[i]);
            }
        }
        while (!stack.isEmpty()) {
            System.out.print(stack.pop() + " ");
        }
        System.out.println();
        System.out.println("max increase seq length is :" + max);

    }

    /**
     * On2 DP
     */
    public void maxIncreaseSeqDP() {
        int max = Integer.MIN_VALUE;
        int[] dp = new int[arr.length + 1];
        dp[0] = 1;
        for (int i = 1; i < arr.length; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(dp[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, dp[i]);
        }
        System.out.println("DP On2 :" + max);
    }

    /**
     * DP O(nlogn) maxV[i] 记录长度是i的递增序列的最大元素的最小值 有 i<j 时 maxV[i]<maxV[j]
     * 反证：如果i<j 有maxV[i]>=maxV[j] ，则有a1，a2.....ai 且有b1,b2....bi....bj ，因为maxV[i]>=maxV[j] ，
     * 所以a[i]>b[j] => a[i]>=b[j]>b[i]  =>a[i] 不是长度是i的递增子序列的最大元素的最小值，矛盾
     * 所以 有 i<j 时 maxV[i]<maxV[j]
     */
    public void maxIncreaseSeqOpt() {
        int[] maxV = new int[arr.length];
        maxV[1] = arr[0];
        int nmax = 1;
        for (int i = 1; i < arr.length; i++) {
            int s = 1, e = nmax;
            while (s <= e) {
                int mid = (s + e) >> 1;
                if (maxV[mid] < arr[i]) {
                    s = mid + 1;
                } else {
                    e = mid - 1;
                }
            }
            nmax = Math.max(nmax, e + 1);
            maxV[e + 1] = arr[i];
        }
        System.out.println(nmax);
        for (int i = 0; i < maxV.length; i++) {
            System.out.print(maxV[i] + " ");
        }
        System.out.println();
    }

    /**
     * DP O(nlogn) minV[i] 记录长度为i的递减序列的最小元素的最大值 有 i>j 时 minV[i]<minV[j]
     */
    public void maxDecreaseSeqOPT() {
        int[] minV = new int[arr.length];
        int nmax = 1;
        minV[1] = arr[0];
        for (int i = 1; i < arr.length; i++) {
            int s = 1, e = nmax;
            while (s <= e) {
                int mid = (s + e) >> 1;
                if (minV[mid] < arr[i]) {
                    e = mid - 1;
                } else {
                    s = mid + 1;
                }
            }
            nmax = Math.max(nmax, e + 1);
            minV[e + 1] = arr[i];
        }
        for (int i = 0; i < minV.length; i++) {
            System.out.print(minV[i] + " ");
        }
        System.out.println();
        System.out.println("max decresase seq is :" + nmax);
    }

    /**
     * DP O(n2)
     */
    public void maxDecreaseSeqDP() {
        int max = 1;
        int[] dis = new int[arr.length];
        Arrays.fill(dis, 1);
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i] < arr[j]) {
                    dis[i] = Math.max(dis[i], dis[j] + 1);
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, dis[i]);
            System.out.print(dis[i] + " ");
        }
        System.out.println("\nmax decrease seq is :");
        Stack<Integer> stack = new Stack<Integer>();
        int prev = Integer.MIN_VALUE;
        for (int i = dis.length - 1, t = max; i >= 0; i--) {
            if (t >= 1 && t == dis[i] && arr[i] > prev) {
                stack.push(arr[i]);
                t--;
            }
        }
        while (!stack.isEmpty()) {
            System.out.print(stack.pop() + " ");
        }
        System.out.println();
    }

    public static void main(String args[]) {
        int[] arr = { 2, 3, 4, 5, 2, 3, 4, 9 };
        ArraysSeq arraysSeq = new ArraysSeq(arr);
        arraysSeq.maxIncreaseSeq();
        arraysSeq.maxIncreaseSeqDP();
        System.out.println("*******************************");
        arraysSeq.maxIncreaseSeqOpt();
        System.out.println("-------------------------------");
        int[] arr1 = { 9, 4, 3, 2, 5, 4, 3, 2 };
        ArraysSeq arraysSeq1 = new ArraysSeq(arr1);
        arraysSeq1.maxDecreaseSeqDP();
        arraysSeq1.maxDecreaseSeqOPT();
    }
}