P2501 [HAOI2006] DP

题意

传送门 P2501 [HAOI2006]数字序列

题解

改变最少的数字，使序列单调严格上升。考虑补集，即原序列中最长的子序列，其中任意位置 $i,j$ 的数字满足 $A_i-A_j\ge i-j$。设 $B_i=A_i-i$，问题转化为求 $B$ 中的最长不降子序列，转化为经典的类 $LIS$ 问题，使用二分优化的 $DP$ 求解，时间复杂度 $O(N\log N)$。

在改变数字最少的条件下，最小化改变的绝对值之和。那么可以通过记录以任意位置为子序列末尾元素的情况下，前一个元素的位置，递推求解绝对值之和的最小值。为方便起见，设子序列首尾元素分别为 $B$ 中元素不会取到的极小、极大值。

问题转化为已知子序列末尾元素 $B_i$ 及其前一元素 $B_j$，求解使 $[j+1,i)$ 区间单调不降的改变的绝对值之和的最小值。可以证明，满足答案的改变后的区间，存在一组构造，仅由 $B_i,B_j$ 构成；即存在位置 $k$，区间 $[j+1,k)$ 为 $B_j$，区间 $[k,i)$ 为 $B_i$。

考虑一个经典问题，即求满足使 ${\sum }_i|A_i-x|$ 最小的 $x$。考虑在任意位置移动，容易得到答案，即 $A$ 的中位数（若 $A$ 规模为偶数，设使 $A$ 有序后正中间两个元素为 $A_i,A_{i+1}$，则答案取值范围为 $[A_i,A_{i+1}]$）。若 $x$ 不能取到 $A$ 的中位数，显然在以中位数为分隔的同侧区间，越逼近中位数则答案更优。在本问题中，最长不降子序列的邻项元素 $B_j,B_i(j<i)$，满足区间 $[j+1,i)$ 内任意元素 $B_k<B_j$ 或 $B_k>B_i$，否则不满足子序列的最长性。那么改变 $[i+1,j)$ 内的任意区间为 $x$，使 ${\sum }_k|B_k-x|$ 最小，取 $x$ 为 $B_i,B_j$ 两者之一，为一组满足最优解的构造。

对于需要改变的任意区间 $[j+1,i)$，假设全部元素改变为 $B_i$，再顺序扫描一遍区间，将前缀的全部元素改变为 $B_j$，同时更新答案即可。代码如下，总时间复杂度 $O(N^3)$，在随机数据下运行较快。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 35005, maxb = 10000000;
int N, A[maxn], B[maxn], dp[maxn];
ll sum[maxn];
vector<int> id[maxn];

int read()
{
    int x = 0;
    char c = 0;
    for (; !isdigit(c); c = getchar())
        ;
    for (; isdigit(c); c = getchar())
        x = (x << 1) + (x << 3) + c - '0';
    return x;
}

int main()
{
    N = read();
    for (int i = 1; i <= N; ++i)
        A[i] = read(), B[i] = A[i] - i;
    B[0] = -maxb, B[N + 1] = maxb;
    memset(dp, 0x3f, sizeof(dp));
    memset(sum, 0x3f, sizeof(sum));
    dp[0] = B[0], sum[0] = 0;
    id[0].push_back(0);
    for (int i = 1; i <= N + 1; ++i)
    {
        int d = upper_bound(dp, dp + N + 2, B[i]) - dp;
        dp[d] = B[i];
        id[d].push_back(i);
        for (auto &j : id[d - 1])
        {
            if (B[i] < B[j])
                continue;
            ll s = sum[j];
            int x = B[i] - B[j];
            for (int k = j + 1; k < i; ++k)
                s += abs(B[k] - B[i]);
            ll mn = s;
            for (int k = j + 1; k < i; ++k)
                s += B[k] < B[j] ? -x : x, mn = min(mn, s);
            sum[i] = min(sum[i], mn);
        }
    }
    int len = upper_bound(dp, dp + N + 2, B[N + 1]) - dp - 2;
    printf("%d\n%lld\n", N - len, sum[N + 1]);
    return 0;
}

仍可以进一步优化。上述算法中，对于区间 $[j+1,i)$，维护将区间全部元素改变为 $B_i$ 的绝对值之和 $s$，维护将区间前缀全部转换为 $B_j$ 的单位贡献最大值。将区间前缀信息，转化为区间信息 $a$ 与区间后缀信息 $mx$ 之差进行维护
$$\{\begin{array}{l}s={\sum }_{k\in [j+1,i)}|B[i]-B[k]|\\ a={\sum }_{k\in [j+1,i)}[B_k>B_i]-[B_k<B_j]\\ mx={\max }_{j\le l<i}{\sum }_{k\in [l+1,i)}[B_k>B_i]-[B_k<B_j]\end{array}$$ 则改变区间 $[j+1,i)$ 使之满足条件，最小改变的绝对值之和为 $s+(B_i-B_j)\times (a-mx)$。上述维护仅拓展了区间左界，那么可以固定子序列末尾元素为右界，倒序扫描子序列末尾元素的前一元素，时间复杂度为 $O(N)$。则总时间复杂度优化为 $O(N^2)$。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 35005, maxb = 10000000;
int N, A[maxn], B[maxn], dp[maxn];
ll sum[maxn];
vector<int> id[maxn];

int read()
{
    int x = 0;
    char c = 0;
    for (; !isdigit(c); c = getchar())
        ;
    for (; isdigit(c); c = getchar())
        x = (x << 1) + (x << 3) + c - '0';
    return x;
}

int main()
{
    N = read();
    for (int i = 1; i <= N; ++i)
        A[i] = read(), B[i] = A[i] - i;
    B[0] = -maxb, B[N + 1] = maxb;
    memset(dp, 0x3f, sizeof(dp));
    memset(sum, 0x3f, sizeof(sum));
    dp[0] = B[0], sum[0] = 0;
    id[0].push_back(0);
    for (int i = 1; i <= N + 1; ++i)
    {
        int d = upper_bound(dp, dp + N + 2, B[i]) - dp;
        dp[d] = B[i];
        id[d].push_back(i);
        int pre = i - 1, a = 0, mx = 0;
        ll s = 0;
        for (int j = (int)id[d - 1].size() - 1; j >= 0; --j)
        {
            int cur = id[d - 1][j];
            if (B[cur] > B[i])
                continue;
            for (int k = pre; k > cur; --k)
                s += abs(B[i] - B[k]), a += B[k] > B[i] ? 1 : -1, mx = max(mx, a);
            sum[i] = min(sum[i], sum[cur] + s + (ll)(B[i] - B[cur]) * (a - mx));
            pre = cur;
        }
    }
    int len = upper_bound(dp, dp + N + 2, B[N + 1]) - dp - 2;
    printf("%d\n%lld\n", N - len, sum[N + 1]);
    return 0;
}