蓝书（算法竞赛进阶指南）刷题记录——POJ3017 Cut the Sequence（DP+单调性优化+队列+set）

题目：POJ3017.
题目大意：给定一个长度为$n$的正整数序列$a$，要求把这个序列分成若干段使得每一段的和不超过一个给定的常数$m$，使得每一段的最大值之和最小，输出最小值.
$1\le n\le 10^5$.

首先这道题显然是个DP，考虑设$f[i]$表示前$i$个数划分成若干段的最小代价，容易列出方程：
f [ i ] = min ⁡ j ∈ [ 1 , i ] , ∑ t = j i a [ t ] ≤ m { f [ j − 1 ] + max ⁡ k = j i { a [ k ] } } f[i]=\min_{j\in[1,i],\sum_{t=j}^{i}a[t]\leq m} \{ f[j-1]+\max_{k=j}^{i} \{ a[k] \} \} f[i]=j∈[1,i],∑t=ji​a[t]≤mmin​{f[j−1]+k=jmaxi​{a[k]}}

容易发现通过预处理区间的最大值，并且同时存一个最小的变量$l$使得${\sum }_{j=l}^{i}a[j]\le m$，可以做到$O(n^2)$解决这个DP，然而还是TLE.

现在考虑分析一下这个DP的性质来优化.容易发现$f[i]$是单调递增的，而且对于一个确定的$i$， g ( j ) = max ⁡ k = j i { a [ k ] } g(j)=\max_{k=j}^{i}\{ a[k] \} g(j)=maxk=ji​{a[k]}是单调递减的.

现在我们考虑对于从$i$变成$i+1$时最值$g(j)$的变化.容易发现$g(j)$的末尾会增加一个$g(i+1)=a[i+1]$，并且$g(j)$原来的末尾一段也会变成$a[i+1]$；与此同时，$g(j)$前面的一段会消失无法取到.

然后我们会发现这个东西性质很好，我们可以把所有$g(j)$相同的$j$并成一段，然后用队列维护这些段就可以了，容易发现操作段的总数量是线性的.

在考虑怎么求这些段中最小的值转移，显然对于每一个段$[l_i,r_i]$，我们必然取左端点来转移，并且此时转移过去的值为$f[l_i-1]+a[r_i]$.

然后我们会发现，这个东西好像是个定值啊，那我们直接把这些段放进一个set不就可以找最小值了…

然后我们就用队列+set解决了这个问题，时间复杂度$O(n\log n)$.

具体实现的时候，不需要真的在队列和set里面存区间，在队列里只需要存每一个段的右端点，在set里只需要存贡献值就好了.

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=100000;

int n;
LL m,a[N+9];
int q[N+9],hd,tl;
multiset<LL>s;
LL dp[N+9],ans;

Abigail into(){
  scanf("%d%lld",&n,&m);
  for (int i=1;i<=n;++i)
    scanf("%lld",&a[i]);
}

Abigail work(){
  if (ans<0) return;
  hd=1;tl=0;
  int l=1;
  LL sum=0;
  for (int i=1;i<=n;++i){
  	for (;hd<=tl&&a[q[tl]]<=a[i];--tl)
	  s.erase(s.find(dp[q[tl-1]]+a[q[tl]]));
  	q[++tl]=i;
  	s.insert(dp[q[tl-1]]+a[i]);
  	sum+=a[i];
  	for (;l<=i&&sum>m;sum-=a[l++])
  	  if (l==q[hd]) s.erase(s.find(dp[q[hd-1]]+a[q[hd]])),++hd;
  	if (l>i) {ans=-1;return;}
  	s.erase(s.find(dp[q[hd-1]]+a[q[hd]]));
  	q[hd-1]=l-1;
  	s.insert(dp[l-1]+a[q[hd]]);
  	dp[i]=*s.begin();
  }
  ans=dp[n];
}

Abigail outo(){
  printf("%lld\n",ans);
}

int main(){
  into();
  work();
  outo();
  return 0;
}