优先队列简单三题：POJ3253 POJ 2431 POJ 3614

POJ 3253

题意：将一块很长的木板分成N块，其长度为L1 L2....LN ，约定未切割前模板的长度恰好为切割后木板长度的总和，求出所需的木板的最小开销。

样例： 3

            8 5 8

输出 34---------> 8+5=13  13+8=21  一共要13+21=34的木板长度。

思路：去画哈夫曼树求最小路径长度吧，嗯就是这样。。每次拿两个元素中最小的去变成一个新的然后再和剩下的去构成新的，直到只有一个元素为止。

            因此可以用优先队列来维护这样一个过程，每次取出两个最小的，然后相加，把相加后的继续加入优先队列中。。。模拟这个过程即可。

代码：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main()
{
    int n,l[20005];
    while(cin>>n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>l[i];

        }
        long long ans=0;
        priority_queue<int,vector<int>,greater<int> > q;//让它从小到大取数
        for(int i=0;i<n;i++)
        {
            q.push(l[i]);
        }
        while(q.size()>1)
        {
            int l1=q.top();
            q.pop();
            int l2=q.top();
            q.pop();
            ans+=l1+l2;
          //  cout<<l1<<"~"<<"!"<<l2<<"@"<<l1+l2<<endl;
            q.push(l1+l2);

        }
        cout<<ans<<endl;
    }


    return 0;
}

//类似于哈夫曼树求最小WPI。。。

POJ 2431

题意：一个人驾驶一辆卡车要行驶L的长度，开始车上有P升的汽油，行驶途中一共有N个加油站，第i个加油站在距离起点AI的地方，最多可以给卡车加BI的汽油，问是否可以到达目的地。

思路：首先把距离加油站的距离转换成离开起点的距离，然后可以想像成：在到达加油站I的时候，就可以获得一次在这之后的任何时候都可以加BI汽油的权利，然后在这之后需要加油时，就认为是在之前经过的加油站加的油就好了，所以每次都应该尽量到加油量最大的加油站。

看代码应该更好理解：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
struct node{
int pos;
int val;


}a[10005];
bool cmp(node a,node b)
{
    return a.pos<b.pos;//按距离起点的最小值升序排列
}

int n;
int l;
int p;


int main()
{

    while(cin>>n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>a[i].pos>>a[i].val;
        }
        cin>>l>>p;
        for(int i=0;i<n;i++)
        {
            a[i].pos=l-a[i].pos;
        }
        a[n].pos=l;
        a[n].val=0;
        n++;
        sort(a,a+n,cmp);
        int sum=p;
        int ans=0;
        int tt=0;
        priority_queue<int> q;
        int flag=0;
        for(int i=0;i<n;i++)
        {
            int d=a[i].pos-tt;//记录当前到距下一个加油站的距离
            while(sum-d<0)//即使小于0也没关系，只要优先队列里面有元素咱们就能加油
            {
                if(q.size()==0)
                {
                    flag=1;
                    break;
                }
                sum+=q.top();
               // cout<<sum<<"~";
                q.pop();
                ans++;
            }
            sum-=d;
            tt=a[i].pos;
            q.push(a[i].val);
        }
        if(flag==1)
        {
            cout<<-1<<endl;
        }
        else
        {
            cout<<ans<<endl;
        }
    }
    return 0;
}

POJ 3614

题意：给你C头奶牛和L种防晒霜，接下来C头奶牛每头奶牛都有一个可接受的阳光值，若低于这个值将会无效，高于这个值将会被灼伤，然后L种防晒霜，防晒霜可以固定太阳的强度，但是对于每种防晒霜它只有COVER瓶，问最多能让最多的奶牛享受到阳光。

思路：对于奶牛对阳光的适宜程度按照最小值的升序排列，对于防晒霜的固定太阳强度，也按升序排列，对于每一种防晒霜，如果奶牛的最低享受值小于等于这种防晒霜的功效，就把该牛的最高承受值放入优先队列，然后每次取出每头牛的最高承受值中的最小者，用来消耗防晒霜。

我们来看给的数据：

3头牛 2种防晒霜

牛的承受能力分别是

3-10

2-5

1-5

防晒霜的固定指数和数量为

6 2

4 1

所以指数6可以给第一头牛用 多了一瓶无用，4可以给任意的后两头牛中的其中一个用，用完了没的多，故答案为2.

然后我们再来想想为什么要取出最大值的最小者：

再看一组数据 2 2 

牛

1 - 10

1 - 5

霜

4 1

7 1

如果先取出来的是10 用4可以让它晒太阳，但是剩下的那头牛就没办法了，而取出的是5 ，把4给了它用，剩下的1-10的牛 7 也能满足它所以是2

嗯。。大概就是这样咯。

代码：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;

int c,l;
struct cow{

int mina;
int maxn;

}a[2505];

struct shuang{
int spf;
int co;

}b[2505];

bool cmp1(cow a,cow b)
{
    return a.mina<b.mina;
}

bool cmp2(shuang a,shuang b)
{
    return a.spf<b.spf;
}

int main()
{
    while(cin>>c>>l)
    {
        for(int i=0;i<c;i++)
        {
            cin>>a[i].mina>>a[i].maxn;
        }
        for(int i=0;i<l;i++)
        {
            cin>>b[i].spf>>b[i].co;
        }
        sort(a,a+c,cmp1);//按照左边最小值排序
        sort(b,b+l,cmp2);//按照固定阳光最小值排序
        priority_queue<int,vector<int>,greater<int> > q;
        int ans=0;
        int j=0;
        for(int i=0;i<l;i++)
        {
            while(j<c&&a[j].mina<=b[i].spf)//从最小的阳光固定值开始，找到这个防晒霜有用的
            {
                q.push(a[j].maxn);         //所有符合条件的牛，把他们的最大承受值放入优先队列
                j++;
            }
            while(q.size()!=0&&b[i].co!=0)//每次取出最大值中的最小者。
            {
                int x=q.top();
                q.pop();
                if(x<b[i].spf)
                {
                    continue;
                }
                 else
                 {
                       ans++;
                    b[i].co--;
                 }

            }
        }
        cout<<ans<<endl;
    }

    return 0;

}

这三题蛮基本，等周末有时间再写个我认为比较不错的一道用优先队列解题的好题= = （因为弱菜错了N次，所以觉得有必要发来警醒自己），就这样吧。。碎了。。