【B-Station】解题报告

                                 B-Station 

试题描述 

    在离著名的国家Berland 不远的地方，有一个水下工作站。这个工作站有N 
层。已知：是第i 层装有W  的水，最多可以容纳L  的水，恐怖分子炸毁第i 层 
                           i                      i 

的代价是P 。第i 层一旦被炸毁，该层所有的水都将倾泻到第i+1 层。如果某一 
           i 

层的水量超过了它的容量(即L )，那么该层就将自动被毁坏，所有的水也会倾泻 
                              i 

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

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

输出 

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

样例 

Input 
3 
1000 1000 1 
0 1000 2 
2 10 100 

Output 
1 
2 

考试题第二题

这道题我用朴素深搜方法过了5组。

逼近解的思路和欧教讲的差不多。

1、可以证明，所有被破坏的楼层是一个完整区间（中间不会有断开的地方）

2、从枚举的第一个破坏点，向下一个模拟过程。

欧教介绍了一种方法。

从这个方法我联想起了以前的一道国家队选拔赛的题，欧教讲的，要把所有常数移项到一边，变量移项到一边，然后根据变量或常量的单调性来解题。

Bomb[p]]表示要炸的集合。S表示前i层总水量。L是限制

Bomb[p]={p}∪{i |i>p S_i-S_p-1<=L_i}

移项得

Bomb[p]={p}∪{i |i>p W_i<=S_p-1}

这时候S是p的单调递增函数。

因此就可知随着p的减小，必须被炸掉的楼层数量在减少。

因此考虑使用大根堆，每次将

Sp-2<Wi<=Sp-1的i弹出来，并将p放入堆中。

最后要注意输出的问题。就根据Bomb[p]={p}∪{i |i>p S_i-S_p-1<=L_i}就好了

记录方案时只需要记录P的值

//======================================================================

这道题我认为。

考察了。数学思维、堆的运用。

这道题的优化在于，对于斜杠部分，朴素方法求解了多次。

实际上不需要考虑，代价的变化，只取决于圆圈部分。

由于S的变化，Sp-2<Wi<=Sp-1的i出堆，就不用枚举了。

总时间复杂度O(nlogn)

//=====================================================================

引用王哥的题解

//容易得知，要炸掉的工作站必然是一個連續的區間[p, n]。

//若存在p'∈[p, n]，不被炸掉，
//那麼一定可以只炸掉(p', n]
//且方案更優。

//樸素方法：枚舉所有的p，再枚舉[p, n]中所有的i，
//若(sigma (int k = p; k < i + 1; ++k) W[i]) <= L[i]，(*)
//則炸掉i，否則不炸掉i，讓i - 1來引爆i。

//W[i], L[i]的含義如題目中的敘述。

//優化：
//記sum[i] = (sigma (int j = 1; j < i + 1; ++j) P[i])，
//則(*)式變形為：
//sum[i] - sum[p - 1] <= L[i]，
//移項，得sum[i] - L[i] <= sum[p - 1]
//（由於在枚舉p時，i相對於p是變量，把變量移到一邊便於分析）
//又記sum[i] - L[i] = tmp[i]，
//所以(*)式最終變形為tmp[i] <= sum[p - 1]。

//考慮從p + 1到p的代價變化：
//第p層必須引爆，故代價加上P[i]；
//(*)式由tmp[i] <= sum[p]變到了tmp[i] <= sum[p - 1]，
//而sum[p - 1] < sum[p],
//所以將原來的滿足tmp[i] > sum[p - 1]的i的P值從代價中減去。

//這裡只需要用大根堆維護出當前方案的所有tmp值，
//每次將tmp值大於sum[p - 1]的堆頂元素不停彈出即可，
//就可以找到最佳方案了。

//======================================================================

错了好多地方。又一次地打错了del，因为没有返回值！！！

大根堆写错了，父亲应该和较小的交换。

交换函数写错了。（a^=b;b^=a;a^=b;）

(DFS版本就不写了)

//========================================================================

#include <cstdio>

long heap[150002];
long size = 0;
long w[150002];
long n;
long p[150002];
long sum[150002];
long l[150002];

void swap(long a,long b)
{
    heap[a] ^= heap[b];
    heap[b] ^= heap[a];
    heap[a] ^= heap[b];
}

void adjust_up(long l)
{
    while ((l>>1)>0)
    {
        if (w[heap[l]]>w[heap[l>>1]])
            swap(l,l>>1);
        else
            break;
        l>>=1;
    }
}

void adjust_down(long l)
{
    while ((l<<=1)<size+1)
    {
        //大根堆，根要跟较大的交换，使较大的在上面
        if (l+1<=size&&w[heap[l + 1]]>w[heap[l]])l++;
        if (w[heap[l]]>w[heap[l>>1]])swap(l,l>>1);
        else break;
    }
}

long del()
{
    if (size==0)
        return -1;
    long tmp = heap[1];
    heap[1] = heap[size];
    size--;
    adjust_down(1);
    return tmp;/删除要返回！！
    
}

void insert(long a)
{
    heap[++size] = a;
    adjust_up(size);
}

long gettop()
{
    return heap[1];
}

int main()
{
    freopen("bstation.in","r",stdin);
    freopen("bstation.out","w",stdout);
    
    scanf("%ld",&n);
    for (long i=1;i<n+1;i++)
    {
        long tmp;
        scanf("%ld%ld%ld",&tmp,l+i,p+i);
        sum[i] = sum[i-1]+tmp;
        w[i] = sum[i]-l[i];
    }
    
    long ans = n;
    long long min = p[n];
    long long now = 0;
    for (long po=n;po>0;--po)
    {
        now+=p[po];
        insert(po);
        while (size>0&&w[gettop()]>sum[po-1]){now-=p[del()];}
        if (now < min)
        {
            ans = po;
            now = min;
        }
    }
    for (long i=ans;i<n+1;i++)
    {
        if (sum[ans-1]>=w[i])
            printf("%ld\n",i);
    }
}

陈样。枚举+剪枝

program BStation;                    {朴素+剪枝,居然比标程快!}
var
  n,i,j,t,k,ans,s:longint;
  w,l,p:array[1..150000] of longint;
//==================================
begin
  assign(input,'BStation.in'); reset(input);
  assign(output,'BStation.out'); rewrite(output);
  read(n);
  for i:=1 to n do read(w[i],l[i],p[i]);
  ans:=p[n]; s:=n; k:=p[n];
  for i:=n-1 downto 1 do             {枚举最早从哪一个点炸~~}
  begin
    t:=w[i];
    if w[i]<=l[i] then k:=p[i] else k:=0;  {可能不炸自己倒塌}
    if k>ans then continue;                {最优性剪枝}
    for j:=i+1 to n do
    begin
      t:=t+w[j];
      if t<=l[j] then
      begin
        k:=k+p[j];
        if k>ans then break;               {继续剪,要剪干净~~}
      end;
    end;
    if ans>k then                          {维护最优值}
    begin
    ans:=k;
    s:=i;
    end;
  end;
  if w[s]<=l[s] then writeln(s);           {输出方案}
  t:=w[s];
  for i:=s+1 to n do
  begin
    t:=t+w[i];
    if t<=l[i] then writeln(i);
  end;
  close(input); close(output);
end.

{
这种方法只有在不会优化的情况下用，不然遇到NB的数据就会被卡~~比如说一个比一个更优，就没法剪~~
其他内容见正确优化的程序中~
from:mz cy
}