BZOJ 1563 四边形不等式

Description

Input

Output

对于每组数据，若最小的不协调度不超过1018，则第一行一个数表示不协调度若最小的不协调度超过1018，则输出"Too hard to arrange"(不包含引号)。每个输出后面加"--------------------"

Sample Input

4
4 9 3
brysj,
hhrhl.
yqqlm,
gsycl.
4 9 2
brysj,
hhrhl.
yqqlm,
gsycl.
1 1005 6
poet
1 1004 6
poet

Sample Output

108
--------------------
32
--------------------
Too hard to arrange
--------------------
1000000000000000000
--------------------

【样例说明】
前两组输入数据中每行的实际长度均为6，后两组输入数据每行的实际长度均为4。一个排版方案中每行相邻两个句子之间的空格也算在这行的长度中(可参见样例中第二组数据)。每行末尾没有空格。

HINT

总共10个测试点，数据范围满足：

测试点 T N L P
1 ≤10 ≤18 ≤100 ≤5
2 ≤10 ≤2000 ≤60000 ≤10
3 ≤10 ≤2000 ≤60000 ≤10
4 ≤5 ≤100000 ≤200 ≤10
5 ≤5 ≤100000 ≤200 ≤10
6 ≤5 ≤100000 ≤3000000 2
7 ≤5 ≤100000 ≤3000000 2
8 ≤5 ≤100000 ≤3000000 ≤10
9 ≤5 ≤100000 ≤3000000 ≤10
10 ≤5 ≤100000 ≤3000000 ≤10
所有测试点中均满足句子长度不超过30。

 

四边形不等式优化dp使用条件：

若dp[i] = Min(dp[j] + val(i, j))， 如果val(i, j)满足(val(i, j) + val(i + 1, j + 1) <= val(i, j + 1) + val(i + 1, j),即val满足四边形不等式，则该dp方程满足决策单调性。

即对每一个dp[i]，其转移过来的位置p[i]序列有单调性。

利用决策单调性，将复杂度降低至nlogn。

具体操作：

建一个元素为(x, l, r)(表示l ~ r之间的dp值最优决策都是由位置x处转移)的队列。

(1) 每次更新检查队头的r是否为i - 1，如果是，踢掉；否则更新队头的l值为i；

(2)直接取队头的x值更新dp[i]，即dp[i] = dp[x] + val(i, x)；

接下来要维护队尾满足决策单调

(3)如果队尾的l, x满足dp[x] + val(l, x) > dp[i] + val(l, i) 踢掉; 不断重复此操作

(4)在队尾的区间内二分得到最小的ans(默认r + 1)，使得dp[i] + val(ans, i) < dp[x] + val(ans, x);

(5)更改队尾r为ans - 1；队尾加入(i, ans, n)

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define mp make_pair
#define pli pair<ll, int>

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> TREE
TREE T;
*/

const int M = 1018;
int T, n, l, p, a[100015], sum[100015];
long double dp[100015];
struct gg {
        int x, l, r;
        gg () {}
        gg (int x, int l, int r) : x(x), l(l), r(r) {}
} g[100015];
int ql, qr;
char s[35];
long double val(int i, int j) {
        return dp[j] + pow(abs(sum[i] - sum[j] + i - j - 1 - l), p);
}
int main() {
    scanf("%d", &T);
    while (T--) {
            scanf("%d%d%d", &n, &l, &p);
            for (int i = 1; i <= n; ++i) {
                    scanf("%s", s);
                    a[i] = strlen(s);
                    sum[i] = sum[i - 1] + a[i];
            }
            g[ql = qr = 1] = gg(0, 1, n);
            for (int i = 1; i <= n; ++i) {
                    if (g[ql].r == i - 1) ++ql;
                    else g[ql].l = i;
                    int j = g[ql].x;
                    long double x = abs(sum[i] - sum[j] + i - j - 1 - l);
                    dp[i] = dp[j] + pow(x, p);
                    while (ql <= qr) {
                            int tl = g[qr].l, j = g[qr].x;
                            if (val(tl, j) > val(tl, i)) --qr;
                            else break;
                    }
                    int s = g[qr].l, e = g[qr].r, ans = e + 1, mi;
                    j = g[qr].x;
                    while (s <= e) {
                            mi = s + e >> 1;
                            if (val(mi, j) > val(mi, i)) e = (ans = mi) - 1;
                            else s = mi + 1;
                    }
                    g[qr].r = ans - 1;
                    if (ans <= n) g[++qr] = gg(i, ans, n);
            }
            if (dp[n] <= 1e18) {
                    printf("%lld\n", (ll)dp[n]);
            } else {
                    puts("Too hard to arrange");
            }
            puts("--------------------");
    }
    return 0;
}