sgu148 B-station（Bomb）

题目

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

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

 

 

输入

 

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

 

输出

 

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

Solution1：小根堆+枚举。

从下往上推的话，f[i]是从i层开始炸毁的代价如果炸毁i-1，且s[i]-s[i-2]>l[i],那么从第i-1层开始炸毁的代价是f[i]+c[i-1]-c[i]; 从第k层开始炸毁时只要将第i(k<i<=n)层里（s[i]-s[k-1]>l[i]) 层里之前算作炸毁的层的c[i]减去,并标记没被炸毁.用优先队列优化的话将快很多,只要将当前炸毁的层入队,当满足s[i]-s[k-1]>l[i]时,出队并减去c[i];

#include <cstdio>  
#include <queue>  
#include <utility>  

using namespace std;  

typedef pair<int,int> aii;

const int maxx = 15000+10, INF = 2e9;  

priority_queue< aii > heap;

int n;
int ans = INF,flag = 0,sum = 0,Sum = 0; 

int v[maxx],s[maxx],c[maxx];
int pre[maxx];
bool hash[maxx];

int main()   
{  

//	freopen("Bstation.in","r",stdin);
//	freopen("Bstation.out","w",stdout);
	
    scanf("%d",&n);  
    
	for(int i=n;i>=1;i--)   
    {  
        scanf("%d%d%d",&s[i],&v[i],&c[i]);    
        pre[i] = pre[i+1]+s[i];  
    }   
    
	for(int i=1;i<=n;i++)  
    {  
        for(;!heap.empty() && heap.top().first>pre[i+1]; heap.pop())  
            sum -= heap.top().second;
        heap.push(make_pair(pre[i]-v[i], c[i]));  
        sum+=c[i];  
        if(ans>sum)  
        {  
            ans = sum;  
            flag = i;     
        }  
    }    
    
	for(int i=flag;i>=1;i--)  
    {  
        Sum += s[i];
        if(Sum>v[i])  
            hash[i] = true;   
    }  
    
    for(int i=flag;i>=1;i--)  
        if(!hash[i])  
            printf("%d\n", n-i+1);  
    return 0;  
}

Solution2：类似二分查找的算法。

之前做过B-station，是用堆的方法。奈何考场碰到此题时早已把此方法忘得一干二净/捂脸。所以迫不得已，强行自己创造了

一个类似二分查找的方法来通过此题防止爆零…咳咳咳，这个方法大致是这样的。读入时首先处理（由于本人个人习惯原因，把最高

层叫做第一层。要炸的叫最底层）之后用sum[i]表示重量的前缀和，用val[i]表示炸该层的费用。之后把每层放入结构体。关键字：

d，l，w，id，need（need保存的是压毁此层时至少毁掉的最高层。换句话说，设i层的need为need[i]，只要从need[i]到i-1之间

所有层都已毁坏，第i层就会直接被压毁。而这个need怎么求呢？假设第i层的need[i]为T，则有sum[i]-sum[T-1]>l[i]。经变形得

到sum[T-1]<sum[i]-l[i]。这时候，因为sum单调递增，可知sum[T]>=sum[i]-l[i]。所以可以用lower_bound函数直接找出

need[i]。接下来我们要做的是将结构体依照need进行排序。然后创建一个vector<int> sale[]的数组。sale[i]中存以此层作为最

高层时可以压毁的层的编号。之后就直接自底往上开始枚举最高层。每次枚举时首先tmp += val[i]（都考虑直接炸掉），之后在

sale[i]中进行查找，如果有编号在i层和底层之间，也就是sale[i][j]>i，则tmp-=val[sale[i][j]]。（说明以i为最高层时此层不用

炸）。每次枚举过后比较tmp与Ans。最终就能得到答案。//考试时做了几个小时，生无可恋.jpg。

#include <cstdio>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

const int maxx = 100000 + 100;

struct Edge{
    int id;
    int d;
    int l;
    int w;
    int need;
}Edges[maxx];

long long sum[maxx],val[maxx],cost[maxx];
long long Ans = 1e9 + 100,tmp;
int n;

vector <int> sale[maxx];

bool cmp(Edge a,Edge b){
    if(a.need != b.need)
    return a.need<b.need;
    else
    return a.id<b.id;
}

int main(){
//    freopen("Bomb.in","r",stdin);
//    freopen("Bomb.out","w",stdout);
    
    scanf("%d",&n);
    
    for(int i=n;i>=1;i--){
        scanf("%d%d%d",&Edges[i].d,&Edges[i].w,&Edges[i].l);
        val[i]=Edges[i].d;
        Edges[i].id = i;
    }
    
    for(int i=1;i<=n;i++)
        sum[i]=sum[i-1]+Edges[i].w;
    
    for(int i=1;i<=n;i++){
        int T = lower_bound(sum,sum+i,sum[i]-Edges[i].l)-sum;
        if(T>0) Edges[i].need = T;
        else Edges[i].need = 0;
    }
    
    sort(Edges+1,Edges+n+1,cmp);
    
    for(int i=1;i<=n;i++)
        sale[Edges[i].need].push_back(Edges[i].id);
    
    for(int i=n;i>=1;i--){
        tmp += val[i];
        for(int j=0;j<sale[i].size();j++){
            if(sale[i][j]>i)
            tmp -= val[sale[i][j]];
        }
        Ans = min(Ans,tmp);
    }
    printf("%d",Ans);
    return 0;
}

看来做过的题目还是要好好学懂啊QvQ。