1.        题目

B_station

在离著名的国家Berland不远的地方，有一个水下工作站。这个工作站有N层。已知：是第i层装有Wi的水，最多可以容纳Li的水，恐怖分子炸毁第i层的代价是Pi。第i层一旦被炸毁，该层所有的水都将倾泻到第i+1层。如果某一层的水量超过了它的容量(即Li)，那么该层就将自动被毁坏，所有的水也会倾泻到下一层。

Pivland的恐怖分子想要用最少的钱毁掉第N层，现在他雇佣你来计算，需要炸毁哪些层。

输入:第一行有一个自然数N(1<=n<=15000)。接下来的N行，每行3个整数Wi, Li, Pi(0<=Wi,Li,Pi<=15000)。

输出:输出需要炸毁的层的编号。

样例Input                    样例output

3                                  1

1000 1000 1                  2

0 1000 2

2 10 100

2.        题目实质

这个题讲的也很明白。

3.        算法

首先，不要一看见最优值就认为是动规，这个题找状态......

其实，他是一个枚举。

选择枚举对像：不妨设恐怖分子炸毁的最高层是第p层（第一层是最高层，第N层是最底层）。

因为恐怖分子的目标是毁灭第N层，所以水必须从第p层一直泻下去。如果存在一个i，满足Wp+Wp+1+…+Wi-1+Wi<=Li，也就是说前面几层的水全部泄下来也无法把第i层自动冲毁，那么就必须要使用***把它炸开了。

考察： Wp+Wp+1+…+Wi-1+Wi<=Li
这个式子要求一段的数字和，为了快速，用前缀和：
   令Si=W1+W2+…+Wi（特别的S0=0）。

上式可表示成： Si-Sp-1 <=Li

所以恐怖分子需要炸毁的层的集合就是Bomb[p]={p}∪{i |i>p Si-Sp-1<=Li}

我们枚举p，然后看哪些层需要炸毁。这样就得到了一个O(n2)的算法。

然后，这里主要讲一下优化：

剪枝:在你枚举的时候，在内层循环中记录一下当前炸了这么多层已经花了多少钱，当这个数目大于已经记录的最小值时， break 。（这样就能过）

记忆化：当搜到了一层的时候，已经可以自己冲垮而不用花钱，那么显然将炸的最高层再往上抬，它还是不用花钱，此时就需要将它记录下来，以后不用搜了。也可以在每次需要花钱的时候，记录下还有多少水就可以不用花钱了，到 0 的时候也就不用再搜了。

单调性优化：（大根堆、二分查找、单调队列 etc）

Bomb[p]={p}∪{i |i>p Si-Sp-1<=Li}  è

令Qi=Si-Li，那么：

Bomb[p]={p}∪{i |i>p Qi<=Sp-1}

注意到Sp是随着p的增加而递增的（单调性），观察两个集合：

Bomb[p]={p}∪{i |i>p Qi<=Sp-1}

Bomb[p-1]={p-1}∪{i |i>p-1 Qi<=Sp-2}

因为Sp-2<=Sp-1，所以{i |i>p-1 Qi<=Sp-2}包含于 Bomb[p]，也就是说，Bomb[p-1]是在Bomb[p]的基础上，通过以下操作得到的：

删除所有的i∈Bomb[p]，Qi>Sp-2。（所以找最大值，删除判断就行了）

添加p-1。

针对这两种操作，我们可以使用大根堆(Heap)（单调队列、二分查找什么的都行）。从大到小枚举p，对于每一个p，执行：

Step1. 如果堆的根i满足Qi >Sp-2，那么删除根；否则转Step3。

Step2. 转Step1。

Step3. 添加p-1。

每层至多进堆一次、出堆一次，所以总的时间复杂度是O(nlogn)。对于n<=15000的范围完全能够胜任了。

4.        注意事项

不要一看到最优值就写动规，也适当想一想基础算法。

注意观察数据范围，不要每次一上来就写最厉害（一般也是最难写）的优化，优化优化的不好就会变成退化了，像这个题，三个优化中有一个就可以 AC 。

5.        代码

只用了第一个优化，刚好能过（SueMiller）

var n:longint;

i,j,k:longint;

w,l,p:array[0..15001]of longint;

v,vv:array[0..15001]of boolean;

ans,temp,co:longint;

begin

assign(input,'station.in');reset(input);

assign(output,'station.out');rewrite(output);

fillchar(w,sizeof(w),0);

fillchar(l,sizeof(l),0);

fillchar(p,sizeof(p),0);

readln(n);

for i:=1 to n do

begin

readln(w[i],l[i],p[i]);

end;

if w[n]>l[n] then begin

writeln(0);

close(input);close(output);

halt;

end;

temp:=w[n];

k:=n;

while temp<=l[n] do

begin

dec(k);

temp:=temp+w[k];

end;

ans:=p[n];

fillchar(v,sizeof(v),false);

fillchar(vv,sizeof(vv),false);

vv[n]:=true;

for i:=k downto 1 do

begin

temp:=w[i];

if temp<=l[i] then

begin

co:=p[i];

v[i]:=true;

end;

for j:=i+1 to n do

begin

if temp+w[j]>l[j] then begin

temp:=temp+w[j];

continue

end

else begin

co:=co+p[j];

v[j]:=true;

temp:=temp+w[j];

if co>ans then begin

fillchar(v,sizeof(v),false);

break;

end;

end;

end;

if co<ans then

begin

vv:=v;

ans:=co;

fillchar(v,sizeof(v),false);

end;

end;

writeln(ans);

for i:=1 to n do

if vv[i] then write(i,' ');

writeln;

//  temp:=0;

//  for i:=1 to n do

//    if vv[i] then begin

//      temp:=temp+p[i];

//    end;

//  writeln(temp,'   ##');

close(input);close(output);

end.

大根堆 （Liukeke）

program liukeke;

var

w,p,l,s,q:array[0..15001] of longint;

f:array[0..15001] of longint;

ans:array[0..15001] of longint;

m,ans0,anscost,cost,i,n:longint;

procedure downsift(x:longint);

var

k,temp:longint;

begin

temp:=f[x];

k:=x<<1;

while k<=m do

begin

if(k<m)and(q[f[k]]<q[f[k+1]]) then inc(k);

if q[temp]<q[f[k]] then

begin

f[x]:=f[k];

x:=k;

k:=x<<1;

end

else break;

end;

f[x]:=temp;

end;

procedure upsift(x:longint);

var

k,temp:longint;

begin

temp:=f[x];

k:=x>>1;

while k>0 do

begin

if q[temp]>q[f[k]] then

begin

f[x]:=f[k];

x:=k;

k:=x>>1;

end

else break;

end;

f[x]:=temp;

end;

procedure sort(l,r:longint);

var

i,j,mid,temp:longint;

begin

i:=l;j:=r;mid:=ans[(l+r)>>1];

repeat

while ans[i]<mid do inc(i);

while ans[j]>mid do dec(j);

if i<=j then

begin

temp:=ans[i];

ans[i]:=ans[j];

ans[j]:=temp;

inc(i);

dec(j);

end;

until i>j;

if l<j then sort(l,j);

if i<r then sort(i,r);

end;

begin

assign(input,'station.in');reset(input);

assign(output,'station.out');rewrite(output);

readln(n);

for i:=1 to n do

readln(w[i],l[i],p[i]);

for i:=1 to n do

s[i]:=s[i-1]+w[i];

for i:=1 to n do

q[i]:=s[i]-l[i];

m:=1;

f[1]:=n;

cost:=p[n];

anscost:=p[n];

for i:=n downto 2 do

begin

//

while (q[f[1]]>s[i-2])and(m>0) do

begin

dec(cost,p[f[1]]);

f[1]:=f[m];

dec(m);

downsift(1);

end;

//

inc(m);

f[m]:=i-1;

upsift(m);

//

inc(cost,p[i-1]);

if cost<anscost then

begin

anscost:=cost;

ans:=f;

ans0:=m;

end;

end;

//outit;

sort(1,ans0);

writeln(anscost);

for i:=1 to ans0 do

write(ans[i],' ');

close(input);

close(output);

end.