『一维线性dp的四边形不等式优化』
<更新提示>
<正文>
四边形不等式
定义：设\(w(x,y)\)是定义在整数集合上的的二元函数，若对于定义域上的任意整数\(a,b,c,d\)，在满足\(a\leq b\leq c \leq d\)时，都有\(w(a,d)+w(b,c)\geq w(a,c)+w(b,d)\)成立，则称函数\(w\)满足四边形不等式。
定理1：四边形不等式的等价表达
\(w(x,y)\)是定义在整数集合上的的二元函数，若对于定义域上的任意整数\(a,b\)，在满足\(a< b\)时，都有\(w(a,b+1)+w(a+1,b)\geq w(a,b)+w(a+1,b+1)\)成立，则称函数\(w\)满足四边形不等式。
证明：
设\(a<c\)，则有\(w(a,c+1)+w(a+1,c)\geq w(a,c)+w(a+1,c+1)\)。
若\(a+1<c\)，则有\(w(a+1,c+1)+w(a+2,c)\geq w(a+1,c)+w(a+2,c+1)\)。
两式相加，消去相同项可得：\(w(a,c+1)+w(a+2,c)\geq w(a,c)+w(a+2,c+1)\)。
类似的，只要\(a+k<c\)就可以得到：\(w(a,c+1)+w(a+k,c)\geq w(a,c)+w(a+k,c+1)\)。
所以对于\(a\leq b\leq c\)，就有\(w(a,c+1)+w(b,c)\geq w(a,c)+w(b,c+1)\)。
同理可证对于\(a\leq b\leq c\leq d\)，有\(w(a,d)+w(b,c)\geq w(a,c)+w(b,d)\)。
定理2：决策单调性
定义：对于形如\(f[i]=min_{0\leq j <i}\{f[j]+val(j,i)\}\)的状态转移方程，记\(p[i]\)为\(f[i]\)的最优决策。若\(p\)在\([1,n]\)上单调不减，则称\(f\)具有决策单调性。
在状态转移方程\(f[i]=min_{0\leq j <i}\{f[j]+val(j,i)\}\)中，若函数\(val\)满足四边形不等式，则\(f\)具有决策单调性。
证明：
对于\(\forall i\in[1,n]，\forall j\in[0,p[i]-1]\)，由\(p[i]\)的最优性可得：$$f[p[i]]+val(p[i],i)\leq f[j]+val(j,i)\tag1$$
设有\(i'\in[i+1,n]\)，因为\(val\)满足四边形不等式，所以$$val(j,i')+val(p[i],i)\geq val(j,i)+val(p[i],i')$$
整理可得：
\((1)(2)\)两式相加，可得：
所以，对于\(i\)以后的任意一个\(i'\)，\(p[i]\)都是比任意\(j<p[i]\)更优的决策，故\(f\)具有决策单调性。
诗人小G
Description
小G是一个出色的诗人，经常作诗自娱自乐。但是，他一直被一件事情所困扰，那就是诗的排版问题。
一首诗包含了若干个句子，对于一些连续的短句，可以将它们用空格隔开并放在一行中, 注意一行中可以放的句子数目是没有限制的。小G给每首诗定义了一个行标准长度（行的长度为一行中符号的总个数），他希望排版后每行的长度都和行标准长度相差不远。显然排版时，不应改变原有的句子顺序，并且小G不允许把一个句子分在两行或者更多的行内。在满足上面两个条件的情况下，小G对于排版中的每行定义了一个不协调度, 为这行的实际长度与行标准长度差值绝对值的P次方，而一个排版的不协调度为所有行不协调度的总和。
小G最近又作了几首诗，现在请你对这首诗进行排版，使得排版后的诗尽量协调（即不协调度尽量小），并把排版的结果告诉他。
Input Format
输入包含多组数据。
第一行包含一个整数T，表示诗的数量，接下来是T首诗，这里一首诗即为一组数据。每组数据的第一行包含三个由空格分隔的正整数N、L、P，其中N表示这首诗句子的数目，L表示这首诗的行标准长度，P的含义见问题描述。从第2行开始，每行为一个句子，句子由英文字母、数字、标点符号等符号组成(ASCII码33~127, 但不包含 ‘-’)。
Output Format
对于每组数据，若最小的不协调度不超过10181018，则一行一个数表示不协调度,若最小的不协调度超过10181018，则输出"Too hard to arrange"(不包含引号)。每组数据结束后输出"--------------------"(不包括引号)，共20个"-"，"-"的ASCII码为45，请勿输出多余的空行或者空格。
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
--------------------
解析
设\(f[i]\)代表对前\(i\)句诗版排的最小不协调度，\(a[i]\)为第\(i\)句诗的长度，\(sum[i]\)为\(a[i]\)的前缀和。
其中，设\(val(j,i)=|sum[i]-sum[j]+i-j-1-L|^P\)，那么方程符合上述四边形不等式中提到的状态转移方程的格式。
我们可以证明函数\(val(j,i)\)满足四边形不等式，进而得知\(f\)具有决策单调性，也可以打标发现\(f\)具有决策单调性。现在，我们讨论如何利用决策单调性对动态规划进行优化。
我们首先考虑维护决策数组\(p\)，首先它一定是单调不减的。对于求出一个新的状态\(f[i]\)后，我们要考虑\(i\)可以作为哪些状态的最优决策。由决策单调性可知，数组\(p\)中一定存在一个最小位置\(pos\)，使得\([pos,n]\)中的所有决策都劣于\(i\)，我们需要将\(p\)数组中下标在\([pos,n]\)的值都改为\(i\)。
在数组上大量修改时很费时的，我们不妨用一个队列来代替\(p\)数组，在队列中存储若干个三元组\((j,l,r)\)，代表\(p\)数组中\([l,r]\)位置的值都为\(j\)，这样我们就可以高效地维护队列了。
对于一个新的状态\(f[i]\)，我们先将队头已经过时的决策弹出，然后取队头决策就可以进行转移。
如何加入一个决策\(i\)呢？我们可以将决策\(i\)与队尾的决策逐个比较，如果\(i\)优于队尾的某个整段决策，就将整段决策弹出队列，直到队列为空。或者，遇到某一段决策，\(i\)不比整段决策优，那就在这段决策中进行二分查找，找到最小的\(pos\)即可。
最后，我们加入决策\(i\)，有效范围为\([pos,n]\)。当然，如果\(pos\)处于原本的一段中间，则还需修改原本队尾决策的右端点。
\(Code:\)
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+20;
const long long INF = 1e18;
struct state{int j,l,r;}q[N];
int n,L,p,a[N];
long double f[N],sum[N];
char poem[40];
inline void input(void)
{
scanf("%d%d%d",&n,&L,&p);
for (int i=1;i<=n;i++)
{
scanf("%s",poem);
a[i] = strlen(poem);
sum[i] = sum[i-1] + a[i];
}
}
inline long double power(long double val)
{
if ( val < 0 ) val = -val;
long double res = 1;
int p_ = p;
while ( p_ )
{
if ( 1 & p_ ) res *= val;
p_ >>= 1 , val *= val;
}
return res;
}
inline long double calc(int i,int j)
{
return f[j] + power( sum[i] - sum[j] + i - j - 1 - L );
}
inline int binary_search(state T,int i)
{
int l = T.l , r = T.r;
while ( l + 1 < r )
{
int mid = (l+r) >> 1;
if ( calc( mid , T.j ) < calc( mid , i ) )
l = mid;
else r = mid;
}
if ( calc( l , T.j ) >= calc( l , i ) ) return l;
if ( calc( r , T.j ) >= calc( r , i ) ) return r;
return r+1;
}
inline void dp(void)
{
int head = 1 , tail = 0 , pos;
f[0] = 0 , q[++tail] = (state){0,1,n};
for (int i=1;i<=n;i++)
{
while ( head <= tail && q[head].r < i ) head++;
f[i] = calc( i , q[head].j );
if ( head > tail || calc(n,i) <= calc(n,q[tail].j) )
{
while ( head <= tail && calc(q[tail].l,i) <= calc(q[tail].l,q[tail].j) ) tail--;
if ( head > tail )
q[++tail] = (state){i,i+1,n};
else
{
int pos = binary_search(q[tail],i);
q[tail].r = pos-1;
q[++tail] = (state){i,pos,n};
}
}
}
}
int main(void)
{
int T;
scanf("%d",&T);
while (T--)
{
input();
dp();
if ( f[n] > INF ) puts("Too hard to arrange");
else printf("%lld\n",(long long)f[n]);
puts("--------------------");
}
return 0;
}
<后记>
