POJ Cut the Sequence 单调队列优化DP入门题

Cut the Sequence

Time Limit: 2000MS		Memory Limit: 131072K
Total Submissions: 6478		Accepted: 1780

Description

Given an integer sequence { a_n } of length N, you are to cut the sequence into several parts every one of which is a consecutive subsequence of the original sequence. Every part must satisfy that the sum of the integers in the part is not greater than a given integer M. You are to find a cutting that minimizes the sum of the maximum integer of each part.

Input

The first line of input contains two integer N (0 < N ≤ 100 000),M. The following line contains N integers describes the integer sequence. Every integer in the sequence is between 0 and 1 000 000 inclusively.

Output

Output one integer which is the minimum sum of the maximum integer of each part. If no such cuttings exist, output −1.

Sample Input

8 17
2 2 2 8 1 8 2 1

Sample Output

12

Hint

Use 64-bit integer type to hold M.

Source

POJ Monthly--2006.09.29, zhucheng

/*
 * File:   main.cpp
 * Author: hit-acm
 *
 * Created on 2012年5月22日, 下午11:44
 */

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
#define MIN(A,B) (A<B)?A:B
/*
 * 此题的状态转移方程是很容易写的出来的，dp[i]=min(dp[j)+max(num[j+1->i])])，(sum(num[j+1->i])<=M);
 * 很明显是个n^2的DP，看一下数据范围必然超时，我们不得不想一下如何去优化此dp，使其复杂度变为至少是
 * nlgn级别的，如何去优化成为了一个难题。以我原来的知识是没有任何思路的。现在我能想的就是学习一种新
 * 的思想，就是用单调队列优化。看了很多神人的讲解之后，以此题作为入门学习的题目来进行学习。
 * 我们拿输入來举例：
 * 8 17
 * 2 2 2 8 1 8 2 1
 * 单调队列的变化形式为：
 * 第一个元素插入后：2
 * 第二个元素插入后：2
 * 第三个元素插入后：2
 * 第四个元素插入后：8
 * 第五个元素插入后：8 1
 * 第六个元素插入后：8
 * 第七个元素插入后：8 2
 * 第八个元素插入后：8 2 1
 *
 * 那么如何优化呢？
 * 现在我们先证明一个结论：
 * 有x<y，必然有：dp[x]<=dp[y]
 *(对于这个是很容易理解的，对于y的任何合法分组，x都可以通过
 * 构造，形成与其对应的分组。从而保证dp[x]<=dp[y]恒成立。
 * ）。那么如果我们不考虑任意段的和不超过M这个限制条件的话，
 * 我们就可以利用dp[1]依次更新dp[3]一旦成功就可以直接break掉
 * 而不必，全部都更新一次。
 *
 * 关键是代码如何实现呢？
 * 我们可以设置一个st代表恰好满足：
 * sum[st,i]<=M.同时对单调队列进行更新,使过时的区间最大值消失
 * 那么用:dp[i]=dp[st-1]+当前单调队列的最大值,来更新但前的DP
 * 那么这就是结果么？不是的。比如4 5 3 M为 10.这种情况
 * dp[1]=4, dp[2]=5,dp[3]=dp[2]+3=8,如果按照上式就是：
 * dp[3]=dp[1]+5=9.
 * 为什么会出现这种情况呢？
 * 实际上对于单调队列中的情况如：
 * 8 2 1时。
 * 我们可以保证的是：
 * 8-2 ，2-1之间的满足。
 * 当x<y时，dp[x]+当前队列的最大值<=dp[y]+当前队列的最大值
 * 我们已经证明了：当x<y时，dp[x]<dp[y];
 * 又由于当前队列的最大值是相同的，因此不等式满足。
 * 因此，我们需要把单调队列里的所有备选方案全部拿出来对结果
 * 进行更新，那么得出的就是最优解。
 */

const int MAX = 100011;
long long a[MAX];
long long dp[MAX];
long long sum[MAX];
int p[MAX];
int start, end;

void insert(int x) {
    if (start > end) {
        start = end = 1;
        p[start] = x;
        return;
    }
    while (start <= end && a[p[end]] <= a[x]) end--;
    p[++end] = x;
}

void update(int st) {
    while (start <= end && st > p[start]) start++;
}

void init() {
    start = 1;
    end = 0;
}

int main() {
    int n;
    long long M;
    while (scanf("%d%lld", &n, &M) == 2) {
        init();
        sum[0] = 0;
        dp[0] = 0;
        int st = 1;
        bool flag = false;
        for (int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
            if (!flag && a[i] > M) {
                flag = true;
            }
            sum[i] = sum[i - 1] + a[i];
            insert(i);
            while (sum[i] - sum[st - 1] > M) {
                st++;
            }
            update(st);
            dp[i] = dp[st - 1] + a[p[start]];
            for (int j = start; j < end; j++) {
                dp[i] = MIN(dp[i], dp[p[j]] + a[p[j + 1]]);
            }
        }
        if (flag) {
            printf("-1\n");
        } else {
            printf("%lld\n", dp[n]);
        }
    }
    return 0;
}