USACO OPEN 12 BOOKSELF（转）

原文出处：http://txhwind.blog.163.com/blog/static/2035241792012112285146817/(版权为原作者所有，本博文无营利目的，不构成侵权)

题目大意：（POJ 3017 也是这个）

n本书有各自的高度h_i和宽度w_i. 现在要把它分成若干段，要求每段总宽度不超过l，某段的高度为其中书的高度的最大值。求最小的所有段的高度和。
 
简单题解：
预处理w的前缀和s.
首先得到动规方程：f[i]=min{f[j]+max{h[j+1..i]} | s[i]-s[j]<=l}.
直接做是平方的，如何优化呢？
我们发现f[j]不减，且对某个i，max{h[j+1..i]}不增。
考虑维护hmax值相同的段。那么从i-1到i时，用h[i]把前面hmax比它小的段合并掉。
平衡树维护每段最前面的f值，决策时取最小的。
翱犇思路：用线段树维护所有决策，每次将一段的hmax修改为h[i].
 1 #include<stdio.h>
 2 #include<set>
 3 
 4 using std::multiset;
 5 
 6 const int MAXN=100000+9;
 7 
 8 int h[MAXN],s[MAXN],w[MAXN];
 9 long long f[MAXN];
10 int main()
11 {
12         freopen("bookshelf.in","r",stdin);
13         freopen("bookshelf.out","w",stdout);
14         int n,l,i;
15         int sum=0,head=1,tail=0;
16         multiset<long long> val;
17         scanf("%d%d",&n,&l);
18         for(i=1;i<=n;++i)
19         {
20                 scanf("%d%d",h+i,w+i);
21 
22                 //s记录每段开头
23                 for(s[++tail]=i-1;head<tail && h[i]>=h[s[tail]];--tail)
24                         val.erase(val.find(f[s[tail-1]]+h[s[tail]]));
25                 val.insert(f[s[tail]]+h[i]);
26                 s[tail+1]=i;
27                 for(sum+=w[i];sum>l;sum-=w[s[head]])
28                 {
29                         val.erase(val.find(f[s[head]]+h[s[head+1]]));
30                         if(++s[head]==s[head+1])
31                                 ++head;
32                         else val.insert(f[s[head]]+h[s[head+1]]);
33                 }
34                 f[i]=*val.begin();
35         }
36         printf("%lld\n",f[n]);
37         return 0;
38 }
View Code

 

以下是我的同学的解题报告：不涉及任何侵权问题。。同学的权，随便侵。。。。

这道题的原型是POJ的3017，只是W[I]换成数列中的权值而已；
对题目进行分析，不难得到动规方程f[i]=min(f[j]+max(h[j+1],h[j+2],h[j+3]....h[i]))其中w[j+1]+w[j+2]+...w[j]<=l;

但是这只是O(n^2)的做法，必须想出优化办法；

首先我们会发现一个i状态会与许多j的子状态相关，这种情况大多都是与单调队列的优化相关；但是这道题并不这么明显；

首先，我们向求max的h[j]值方向思考，不难维护出一个单调递减，队头到i的w[i]之和小于l的最大值单调队列；但是这样就将f的值给忽略掉了；

所以我们需要想出f数组的特点，不难看出这是单调递增的，

所以我们猜想：每一个单调队列中的决策点相对于后面的一段都有可能是最优决策点，但是如何证明呢?

如果这个不是最优决策点，那么他后面的一段区间的最大值都与该点相等，而f非递增，所以决策都没有在单调队列中的决策好；

既然我们发现f与单调队列也有关系，那么此题单调队列的方向就已经确定；

维护上述的一个单调队列，在计算f[i]时在单调队列中的所有点都有可能成为决策点，对于这种情况可以用平衡树进行维护，但代码还有许多细节处理

 1  #include<cstdio>  
 2     #include<set>  
 3     #include<iostream>
 4     using namespace std;  
 5     const int mm=111111;  
 6     int a[mm],q[mm],w[mm];  
 7     long long f[mm],sum,tmp,m;  
 8     multiset<long long> sbt;  
 9     int i,l,r,p,n;  
10     int main()  
11     {  
12         scanf("%d%lld",&n,&m);  
13         sbt.clear();  
14         sum=l=0,f[n]=r=-1;  
15         for(p=i=1;i<=n;++i)  
16         {  
17             scanf("%d%d",&a[i],&w[i]);  
18             sum+=w[i];  
19             while(sum>m)sum-=w[p++];   
20             while(l<=r&&a[i]>=a[q[r]])  
21             {  
22                 if(l<r)sbt.erase(f[q[r-1]]+a[q[r]]);  
23                 --r;  
24             }  
25             q[++r]=i;  
26             if(l<r)sbt.insert(f[q[r-1]]+a[q[r]]);  //手动模拟下就会发现对于边界外决策点，其待定决策值为f[q[i]-1]+a[q[i]];
27             while(q[l]<p)  
28             {  
29                 if(l<r)sbt.erase(f[q[l]]+a[q[l+1]]);  
30                 ++l;  
31             }  
32             f[i]=f[p-1]+a[q[l]];  //在i为当前最大值时用p数组更新
33 
34             tmp=*sbt.begin();  
35             if(f[i]>tmp)f[i]=tmp;  
36         }  
37         cout<<f[n];
38         return 0;  
39     }
View Code

 

 摘自另一地方。http://www.cnblogs.com/kedebug/archive/2013/03/01/2939428.html

题意：

长度为 n 的数列，要求把这个数列划分为任意块，每块的元素和小于 m，使得所有块的最大值的和最小。

思路：

1. 很明显的一个转移方程是： dp[i] = max(dp[j] + max(a[j+1], a[j+2], ..., a[i])); 其中满足 sum[i] - sum[j] <= M 的 j 都算，这是一个 O(N * N) 的解法。

2. 如果不去优化枚举 j 的这个过程，就会直接 TLE，如何优化？联系到求最大值，可以想到用最大值的单调队列，队列里面存放的是以 i 为结尾，窗口里面的元素和

   恰好不大于 M 的 j 为左边界，即恰好有 sum[i] - sum[j-1] <= M.

3. 如果是这样的话，还不能够达到目标，因为 1 中最优值点的 j 的选择可能是窗口中的任意一个值，这时候遇到一个困难：确定 j 的位置，使情况最优。

4. 考虑到 dp[i] 是一个单调增的数组，而窗口中的元素是关于最大值递减的，先让 M 足够大，从简单的角度来考虑：对于 a[1] = 8, a[2] = 5, a[3] = 7，对于 dp[3]

   则有 dp[3] = min(dp[0] + 8, dp[1] + 7, dp[2] + 7)，显然 dp[1] <= dp[2]，则进一步优化有 dp[3] = min(dp[0] + 8, dp[1] + 7);

5. 从 4 中我们可以看出点端倪，单调队列中所指向的元素也恰好是 8, 7，所以得出的结论有：对于 dp[i] 只要选择单调队列中所指向的位置的 j 即可保证结果是最优的。

6. 如何维护单调队列中的 dp[j] + max(a[j+1], a[j+2], ..., a[i])，则考虑使用一个平衡树，这样可以把时间复杂度降到最低。

 

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

#define LL long long int

const int MAXN = 100010;

int num[MAXN], deq[MAXN];
LL dp[MAXN];
multiset<LL> optset;

int main()
{
    LL N, M;

    scanf("%lld %lld", &N, &M);
    for (int i = 1; i <= N; ++i)
        scanf("%d", &num[i]);

    LL sum = 0;
    int s = 0, e = -1, p = 1;
    bool flag = false;

    optset.clear();
    for (int i = 1; i <= N; ++i)
    {
        if (num[i] > M)
        {
            flag = true;
            break;
        }

        sum += num[i];
        while (sum > M)
            sum -= num[p++];

        while (s <= e && num[i] >= num[deq[e]])
        {
            if (s < e)
                optset.erase(dp[deq[e-1]] + num[deq[e]]);
            --e;
        }

        deq[++e] = i;
        if (s < e)
            optset.insert(dp[deq[e-1]] + num[deq[e]]);

        while (deq[s] < p)
        {
            if (s < e)
                optset.erase(dp[deq[s]] + num[deq[s+1]]);
            ++s;
        }

        dp[i] = dp[p-1] + num[deq[s]];
        if (s < e && dp[i] > *optset.begin())
            dp[i] = *optset.begin();
    }
    if (flag)
        dp[N] = -1;
    printf("%lld\n", dp[N]);
    return 0;
}
posted @ 2015-08-06 21:42  漫步者。！~  阅读(288)  评论(0)  编辑  收藏  举报