Problem
Description
小 \(Q\) 有 \(n\) 本书,每本书有一个独一无二的编号,现在它们正零乱地在地上排成了一排。
小 \(Q\) 希望把这一排书分成恰好 \(k\) 段,使得每段至少有一本书,然后把每段按照现在的顺序依次放到 \(k\) 层书架的每一层上去。
将所有书都放到书架上后,小 \(Q\) 这才突然意识到它们是乱序的,他只好把每一层的书分别按照编号从小到大排序。排序每次可以在 \(1\) 单位时间内交换同一层上两本相邻的书。
请写一个程序,帮助小 \(Q\) 计算如何划分这 \(k\) 段,且如何交换这些书,使得总交换次数最少。
Input Format
第一行包含两个正整数 \(n,k\)。
第二行包含 \(n\) 个互不相同的正整数 \(a_1, a_2, ..., a_n\),分别表示地面上每本书的编号。
Output Format
输出一行一个整数,即最少的总交换次数。
Sample
Input
6 3
4 3 6 2 5 1
Output
1
Explanation
Explanation for Input
按 \([4, 3, 6][2, 5][1]\) 划分,需要排序 \(1 + 0 + 0 = 1\) 次。
Range
\(1 \le n \le 40000, 1 \le k \le min(10, n), \forall 1 \le a_i \le n\)
Algorithm
\(DP\) ,决策单调性
Mentality
其实决策单调性也没啥可怕的地方,主要重点在于你的思考!
我们先列出最朴素的 \(dp\) 方程:\(dp[i][j]\) 表示将前 \(i\) 本书划分到 \(j\) 层书架的最小代价,那么我们设 \(w(i,j)\) 代表区间 \([i,j]\) 内的逆序对数目,我们就有如下方程:
\[ dp[i][j]=Min_{p<i}(dp[p][j-1]+w(p+1,i)) \]
答案即为 \(dp[n][k]\) 。
这样 \(dp\) 的复杂度为 \(n^2k\) , 时间显然过不去。
那么由于式子非常决策单调性,那么我们考虑打表证明,果然有 \(w\) 函数满足四边形不等式。
随后当我们枚举一个 \(j\) 时,我们设 \(g[i]\) 为 \(dp[i][j]\) 的最优决策点,即 \(dp[i][j]=dp[g[i]][j-1]+w(g[i]+1,i)\),则有 \(g[i-1]\le g[i]\) 。
这个证明很简单,对于两个决策点 \(p<q\) ,如果 \(dp[q]+w\le dp[p]+w\) ,由于 \(w\) 函数越来越大,所以如果 \(q\) 比 \(p\) 更优,那么 \(q\) 永远比 \(p\) 更优。所以我们的最优决策点必定单调右移,即 \(g[i-1]\le g[i]\) 。
那么根据这个单调性搞事情,我们考虑分治 \(dp\) ,对于区间 \([l,r]\) 的 \(dp\) ,我们考虑确定它的最优决策点所在的区间 \([L,R]\) 。那么我们找出 \(mid\) 处的最优决策点 \(p\),根据决策单调性,则区间 \([mid+1,r]\) 的最优决策区间必定为 \([p,R]\) ,而区间 \([l,mid-1]\) 的最优决策区间则必定为 \([L,p]\) 。
根据这样递归分治,每次枚举最优决策区间更新 \(mid\) ,并递归处理,枚举决策区间便构成了一颗类似线段树的情况,那么对于同一递归层数,决策区间的和正好就是 \(O(n)\) ,那么决策区间枚举的总复杂度就是 \(nlog\) ,均摊下来,则我们枚举决策点的复杂度变为 \(log\) ,枚举状态复杂度为 \(O(nk)\) 。
样例的递归分治,当 \(k=2\) 时如下图:
由此可见,每层的决策点枚举只会是 \(O(n)\) ,那么总复杂度为 层数× \(n\) ,即 \(O(nlog)\) 。
接下来还剩一个状态转移,那么我们只需要管 \(w\) 函数如何快速地求出来就好了。这里我们先看我们的处理顺序为先递归左区间再递归右区间,那么大多数时候 \(w\) 的右端点只是根据 \(dp\) 需求不断增加 \(1\) ,递归下去的时候也只是减少一些。
则我们可以考虑维护一个类似莫队的东西,维护一个全局的 \(L\) 与 \(R\) ,每次需要获取答案的时候,我们就将 \(L\) 和 \(R\) 一步一步移动到指定位置,用树状数组动态维护逆序对即可。这样做的话大概总复杂度是 \(nlog\) 带个玄学常数?那么均摊下来就是 \(log\) 的复杂度。
则最后的时间复杂度=枚举状态×枚举决策点×状态转移=\(O(nk)×O(log)×O(log)\)=\(O(nklog^2)\) 。能够通过题目。
Code
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int n, K, sum, L, R, now, a[40001], c[40001], f[40001][11];
void add(int k, int x) {
for (int i = k; i <= n; i += i & -i) c[i] += x;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= i & -i) ans += c[i];
return ans;
}
void Move(int l, int r) //莫队式移动
{
while (L < l) sum -= query(a[L] - 1), add(a[L++], -1);
while (L > l) sum += query(a[L - 1] - 1), add(a[--L], 1);
while (R < r) sum += R - L + 1 - query(a[R + 1]), add(a[++R], 1);
while (R > r) sum -= R - L + 1 - query(a[R]), add(a[R--], -1);
}
void solve(int l, int r, int L, int R) {
if (l > r) return;
int mid = (l + r) >> 1, p = L;
for (int i = L; i <= min(mid - 1, R); i++) {
Move(i + 1, mid);
int Sum = f[i][now - 1] + sum;
if (Sum < f[mid][now]) f[mid][now] = Sum, p = i; //确定最优决策点
}
solve(l, mid - 1, L, p);
solve(mid + 1, r, p, R); //递归
}
int main() {
cin >> n >> K;
L = 1; //初始化莫队指针
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(f, 10, sizeof(f));
for (int i = 1; i <= n; i++) Move(1, i), f[i][1] = sum; //先计算 k=1
for (now = 2; now <= K; now++) solve(1, n, 1, n); //开始递归
cout << f[n][K];
}