最长连续递增序列-leecode—分治法、动态规划

第一种方法：双指针枚举法

    public static int findLengthOfLCIS1(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int n = nums.length;
        int maxLength = 1;
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                if (j + 1 < n && nums[j] < nums[j + 1]) {
                    maxLength++;
                } else {
                    break;
                }
            }
            a[i] = maxLength;
            maxLength = 1;
        }
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            if (a[i] > count) {
                count = a[i];
            }
        }
        return count;
    }

第二种方法：单指针枚举法

    public int findLengthOfLCIS2(int[] nums) {
        if (nums.length == 0)
            return 0;
        int max = 0;
        int count = 1;
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] < nums[i + 1]) {
                count++;
            } else {
                max = Math.max(count, max);
                count = 1;
            }
        }
        max = Math.max(count, max);
        return max;
    }

第仨种方法：分治法

    public static int findLengthOfLCIS3(int[] nums, int left, int right) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int leftCount = 0;
        int rightCount = 0;
        int mergeCount = 0;
        int mid = left + right >> 1;
        //left < right 递归出口
        if (left < right) {
            leftCount = findLengthOfLCIS3(nums, left, mid);
            rightCount = findLengthOfLCIS3(nums, mid + 1, right);
            mergeCount = mergeCount(nums, left, mid, right);
        }
        return maxInThreeNum(leftCount, rightCount, mergeCount);
    }

    public static int mergeCount(int[] nums, int left, int mid, int right) {
        int leftCount = 0;
        for (int i = mid; i >= left; i--) {
            if (i - 1 >= left && nums[i] > nums[i - 1]) {
                leftCount++;
            }
        }
        int rightCount = 0;
        for (int i = mid + 1; i <= right; i++) {
            if (i + 1 <= right && a[i] < a[i + 1]) {
                rightCount++;
            }
        }
        return leftCount + rightCount;
    }

第四种方法：动态规划法

    public static int findLengthOfLCIS4(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int n = nums.length;
        int[] C = new int[n];
        int[] Rec = new int[n];
        C[0] = 1;
        Rec[0] = 0;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                C[i] = C[i - 1] + 1;
                Rec[i] = Rec[i - 1];
            } else {
                C[i] = 1;
                Rec[i] = i;
            }
        }
        int count = 0;
        int index = 0;
        for (int i = 0; i < C.length; i++) {
            if (C[i] > count) {
                count = C[i];
                index = i;
            }
        }
        System.out.println("开始下标和结束下标为：" + Rec[index] + " " + (count -         
                           Rec[index] - 1));
        return count;
    }