最长子序列及拓展

    public int lengthOfLIS(int[] nums) {
        int ans = 1;
        int n = nums.length;
        int[] record = new int[n];
        record[0] = 1;
        for (int i = 1; i < n; i++) {
            int cur = 1;
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    cur = Math.max(cur, record[j] + 1);
                }
            }
            record[i] = cur;
            ans = Math.max(ans, cur);
        }
        return ans;
    }
    public int lengthOfLIS1(int[] nums) {
        int n = nums.length;
        int[] ends = new int[n];
        int len = 0;
        for (int i = 0; i < n; i++) {
            int find = bs1(ends, len, nums[i]);
            if (find == -1) {
                ends[len++] = nums[i];
            } else {
                ends[find] = nums[i];
            }
        }
        return len;
    }
    public int bs1(int[] ends, int len , int val) {
        int l = 0, r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (ends[mid] >= val) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }
    public int bs2(int[] ends, int len , int val) {
        int l = 0, r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (ends[mid] > val) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }

    public int maxEnvelopes(int[][] envelopes) {
        int n = envelopes.length;
        Arrays.sort(envelopes,(a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
        int[] cur = new int[n];
        for (int i = 0; i < n; i++) {
            cur[i] = envelopes[i][1];
        }
        int[] ends = new int[n];
        ends[0] = cur[0];
        int size = 1;
        for (int i = 1; i < n; i++) {
            int find = find(cur[i], ends, size);
            if (find == -1) {
                ends[size++] = cur[i];
            } else {
                ends[find] = cur[i];
            }
        }
        return size;

    }
    public int find(int num, int[] cur, int len) {
        int l = 0;
        int r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (cur[mid] >= num) {
                ans= mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }

    public int kIncreasing(int[] arr, int k) {
        int n = arr.length;
        int ans = 0;
        for (int i = 0; i < k; i++) {
            int[] nums = new int[n];
            int size = 0;
            for (int j = i; j < n; j += k) {
                nums[size++] = arr[j];
            }
            ans += size - f(nums, size);
        }
        return ans;
    }
    public int bs(int len, int[] arr, int num) {
        int l = 0;
        int r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (arr[mid] > num) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }
    public int f(int[] nums,int si) {
        int n = si;
        int[] ends = new int[n];
        int size = 0;
        for (int i = 0; i < n; i++) {
            int find = bs(size, ends, nums[i]);
            if (find == -1) {
                ends[size++] = nums[i];
            } else {
                ends[find] = nums[i];
            }
        }
        return size;
    }

    public int findLongestChain(int[][] pairs) {
        int n = pairs.length;
        Arrays.sort(pairs, (a, b) -> (a[1] - b[1]));
        int cur = -1001;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            int start = pairs[i][0];
            int end =  pairs[i][1];
            if (start > cur) {
                ans++;
                cur = end;
            }
        }
        return ans;
    }
    public int findLongestChain1(int[][] pairs) {
        int n = pairs.length;
        Arrays.sort(pairs, (a, b)-> (a[0] - b[0]));
        int[] ends = new int[n];
        int len = 0;
        for (int[] pair : pairs) {
            int s = pair[0];
            int e = pair[1];
            int find = bs(ends, len, s);
            if (find == -1) {
                ends[len++] = e;
            } else {
                ends[find] = Math.min(ends[find], e);
            }
        }
        return len;
    }
    public int bs(int[] ends, int len, int num) {
        int l = 0, r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (ends[mid] >= num) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        int[] right = right(arr);
        int ans = k;
        int len = 0;
        int[] ends = new int[n];
        for (int i = 0, j = k; j < n; i++, j++) {
            int find = bs2(ends, len, arr[j]);
            int left = find == -1 ? len : find;
            ans = Math.max(ans, left + k + right[j]);
            find = bs2(ends, len, arr[i]);
            if (find == -1) {
                ends[len++] = arr[i];
            } else {
                ends[find] = arr[i];
            }
        }
        ans = Math.max(ans, len + k);
        System.out.println(ans);
    }
    public static int[] right(int[] arr) {
        int n = arr.length;
        int len = 0;
        int[] ends = new int[n];
        int[] res = new int[n];
        for (int i = n - 1; i >= 0; i--) {
            int find = bs1(ends,len, arr[i]);
            if (find == -1) {
                ends[len++] = arr[i];
                res[i] = len;
            } else {
                ends[find] = arr[i];
                res[i] = find + 1;
            }
        }
        return res;
    }
    public static int bs1(int[] arr, int len, int num) {
        int l = 0, r = len - 1;
        int ans = -1;
        while (l <= r) {
             int mid = (l + r) / 2;
             if (arr[mid] < num) {
                 ans = mid;
                 r = mid - 1;
             } else {
                 l = mid + 1;
             }
        }
        return ans;
    }

    public static int bs2(int[] arr, int len, int num) {
        int l = 0, r = len - 1;
        int ans = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (arr[mid] >= num) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return ans;
    }