304. Poet G (advanced guide to algorithm competition, quadrilateral inequality optimization of one-dimensional linear DP)

1. Title link:

Poet Little G

2. The main idea of ​​the topic:

La la la~

3. Analysis:

After doing it for a long time, I finally figured it out (thinking about peach)

Big brother explain

Yes, there is no analysis!

Tucao: The answer must be stored in long double, which is too stupid.

4. Code implementation:

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int M = (int)1e5;

int N, L, P;
char s[35];
int sum[M + 5];
struct node
{
    int j, l, r;
}q[M + 5];
int l, r;

long double f[M + 5];

int bs1(int i)
{
    int l = ::l, r = ::r, mid;
    while(l < r)
    {
        mid = (l + r) >> 1;
        if(q[mid].r >= i)
            r = mid;
        else
            l = mid + 1;
    }
    return q[r].j;
}

long double cal(int i, int j)
{
    long double sum = 1.0, num = abs(::sum[i] - ::sum[j] + i - j - 1 - L);
    for(int i = 0; i < P; ++i)  sum *= num;
    return f[j] + sum;
}

int bs2(int i, int j, int l, int r)
{
    int mid;
    while(l < r)
    {
        mid = (l + r) >> 1;
        if(cal(mid, i) > cal(mid, j))
            l = mid + 1;
        else
            r = mid;
    }
    return r;
}

void ins(int i)
{
    int pos = -1;
    while(l <= r)
    {
        if(cal(q[r].l, i) <= cal(q[r].l, q[r].j))
            pos = q[r--].l;
        else
        {
            if(cal(q[r].r, i) < cal(q[r].r, q[r].j))
            {
                pos = bs2(i, q[r].j, q[r].l, q[r].r);
                q[r].r = pos - 1;
            }
            break;
        }
    }
    if(~pos)
    {
        q[++r].j = i;
        q[r].l = pos;
        q[r].r = N;
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d %d", &N, &L, &P);
        for(int i = 1; i <= N; ++i)
        {
            scanf("%s", s);
            sum[i] = sum[i - 1] + strlen(s);
        }
        l = 1, r = 0;
        q[++r].j = 0, q[r].l = 1, q[r].r = N;
        memset(f, 0, sizeof(f));
        for(int i = 1; i <= N; ++i)
        {
            int j = bs1(i);
            f[i] = cal(i, j);
            while(l <= r && q[l].r <= i)    ++l;
            q[l].l = i + 1;
            ins(i);
        }
        if(f[N] > (ll)1e18) printf("Too hard to arrange\n");
        else                printf("%lld\n", (ll)f[N]);
        for(int i = 0; i < 20; ++i) putchar('-');
        puts("");
    }
    return 0;
}