TP

题意：

• 很清晰，不再赘述。

思路：

• 对于前 50% 的数据显然我们可以 dp 解决。从左到右维护每个位置 i 结尾的 最长不下降子序列，从右到左维护每个位置 i 结尾的 最长不上升子序列。最后枚举任意左右端点 i、j，中间大于等于 k 个数就更改这 k 数即可。

• 对于全部的数据，我们就得考虑优化 枚举 的过程 和 dp 转移的过程（这两过程都是 $O(n^2)$ 的，尝试优化为 $O(nlo{g}_n)$）。

• 列出 dp 的转移公式：

	//朴素 n*n
 	for (int i = 1; i <= n; i++) {
        dp[i] = 1;
        for (int j = 1; j < i; j++)
            if (z[j] < z[i])dp[i] = max(dp[i], dp[j] + 1);
    }

可以发现每次从 [1、i - 1] 我们 找到比 z[i] 小的位置的 最大dp值 转移过来最好；

这就启发我们用权值线段树优化这个找的过程，把 循环 n 次 优化成 树中 $lo{g}_n$ 的查询。

• 权值线段树的思想就是，离散化加排序 z数组 的元素，每次转移时，从比 z[i] 小的区间搜索出最大的 dp值。可以发现这就是一个动态维护区间最大值问题，线段树轻松解决。

$Code:$

#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define debug(x) cout<<"target is "<<x<<endl
#define forr(a,b,c) for(int a=b;a<=c;a++)
#define all(a) a.begin(),a.end()
#define oper(a) (operator<(const a& ee)const)
#define endl "\n"
#define ul (u << 1)
#define ur (u << 1 | 1)
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;

const int N = 200010, M = 500010, MM = 110;
int INF = 0x3f3f3f3f, mod = 998244353;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k;
int z[N], dpl[N], dpr[N];
vector<int> vec;
int find(int x) { //离散化排序后二分查找元素位置
    return lower_bound(all(vec), x) - vec.begin() + 1;
}

struct tree
{
    int l, r, mx;
}tr[N << 2];
inline void pushup(int u) {
    tr[u].mx = max(tr[ul].mx, tr[ur].mx);//维护max
}
void build(int u, int l, int r) {
    if (l == r)tr[u] = { l,r,0 };
    else {
        tr[u] = { l,r,0 };
        int mid = l + r >> 1;
        build(ul, l, mid), build(ur, mid + 1, r);
    }
}
void modify(int u, int d, int f) {
    if (tr[u].l == d && tr[u].r == d) {
        tr[u].mx = f;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (mid >= d)modify(ul, d, f);
        if (mid < d)modify(ur, d, f);
        pushup(u);
    }
}
int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) {
        return tr[u].mx;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        int t = 0;
        if (mid >= l)t = query(ul, l, r);
        if (mid < r)t = max(t, query(ur, l, r));
        return t;
    }
}

void solve() {
    cin >> n >> k;
    forr(i, 1, n)cin >> z[i], vec.push_back(z[i]);
    sort(all(vec));
    vec.erase(unique(all(vec)), vec.end());

    m = vec.size();
    build(1, 1, m);

    int ans = k;

    //先用这个思想维护出从左到右 i 位置的最长不下降子序列
    forr(i, 1, n) {
        int t = find(z[i]);
        int res = query(1, 1, t) + 1;
        //从小于等于z[i]的区间中找 max(dpl值)

        dpl[i] = res;
        ans = max(ans, dpl[i]);

        modify(1, t, res);
        //同时更新此位置，维护此位置 max(dpl值)
    }

    build(1, 1, m);

    //同样维护从右到左 i 位置的最长不上升子序列
    for (int i = n; i; i--) {
        int t = find(z[i]);
        int res = query(1, t, m) + 1;
        dpr[i] = res;
        ans = max(ans, dpr[i]);
        modify(1, t, res);

        //但这里维护的同时要随时与 k 个前的 dpl[be] 取 max
        int be = i - k - 1;
        if (be >= 1) {
            int tt = find(z[be]);
            ans = max(ans, dpl[be] + k + query(1, tt, m));
            //维护到此位置的权值线段树中，在比 z[be] 大的区间中找 max 值

            //这样才能保证没有遗漏，因为中间可能不止空出 k 个数
        }
    }

    //最后还有记录不连接两区间，直接加 k 的情况
    for (int i = 1; i + k <= n; i++)
        ans = max(ans, dpl[i] + k);
    for (int i = n; i - k >= 1; i--)
        ans = max(ans, dpr[i] + k);

    cout << ans;
}

int main() {
    cinios;
    int T = 1;
    forr(t, 1, T) {
        solve();
    }
    return 0;
}
/*
8 2
5 6 100 99 98 97 7 8

//答案是 6
*/