Expedition---poj2431(优先队列-堆的实现)

题目链接：http://poj.org/problem?id=2431

题意：一辆卡车需要行驶 L 距离，车上油的含量为 P，在行驶的过程中有 n 个加油站 每个加油站到终点的距离是ai，每个加油站最多给卡车加 b 单位的油；求最后到达终点需要加油的最少次数；如果不能到达，输出-1；

我们可以从起点开始算，看每次油箱中的油是否能够到达下一个加油站，如果不能就加上已经经过的加油站的所能加的最大加油量，如果能到达，就记录一下此加油站可以被加进去；因为我们每次都需要加进去最大的加油

量，所以我们可以用优先队列；来存，那么每次取出来的就是最大值；

时间复杂度是O（n*logn）

用c++中的STL：

#include<stdio.h>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
#define N 101000
#define INF 0xfffffff
using namespace std;

int n, P, L, ans, f;

struct node
{
    int a,b;
} s[N];

int cmp(node n1,node n2)
{
    return n1.a<n2.a;
}

void slove()
{
    priority_queue<int> Q;///优先队列；

    int pos = , i = ;///pos表示当前所在位置；

    while(i <= n)
    {
        int d = s[i].a - pos;

        while(Q.size() && P < d)///当不能到达下一个加油站时，要取出最大的加油量加进去；
        {
            int p = Q.top(); Q.pop();
            P += p;
            ans ++;
        }
        if(P >= d)
        {
            Q.push(s[i].b);
            pos = s[i].a;
            P -= d;
        }
        else
        {
            ans = -;
            return ;
        }
        i ++;
    }
}

int main()
{
    int i;

    while(scanf("%d",&n) != EOF)
    {
        memset(s, , sizeof(s));

        ans=;

        for(i=; i<n; i++)
            scanf("%d %d",&s[i].a, &s[i].b);

        scanf("%d %d", &L, &P);

        for(i=; i<n; i++)
            s[i].a = L - s[i].a;

        s[i].a = L;
        s[i].b = ;///把终点当成最后一个加油站处理；

        sort(s, s+n+, cmp);

        slove();

        printf("%d\n", ans);
    }
    return ;
}

手写实现堆---优先队列；

#include<stdio.h>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
#define N 11000
#define INF 0x3f3f3f3f
using namespace std;

int Max_Heap[N], K;///K代表Max_Heap的个数；
int p;

void Push(int x)///在最大堆中插入x；
{
    Max_Heap[K++] = x;///放到最后一个节点处；

    int t = K-;

    while(Max_Heap[t] > Max_Heap[t/] )///当它的值大于它的父节点的值时，要交换一下位置；
    {
        swap(Max_Heap[t], Max_Heap[t/]);
        t = t/;
    }
}
void Pop()
{
    K --;///删除元素，堆中总个数减一；

    Max_Heap[] = Max_Heap[K];///把最后一个数放到最上面，然后一步一步往下更新堆；

    Max_Heap[K] = -;///防止越界，相当于建立哨兵；

    int t = ;///从第一个节点开始往下更新；

    while( Max_Heap[t] < Max_Heap[t*] || Max_Heap[t] < Max_Heap[t*+])
    {
        if(Max_Heap[t] < Max_Heap[t*] && Max_Heap[t*] > Max_Heap[t*+])
        {///左儿子大于它时，并且满足左儿子大于右儿子，让左儿子上去；
            swap(Max_Heap[t], Max_Heap[t*]);
            t = t*;
        }
        else
        {
            swap(Max_Heap[t], Max_Heap[t*+]);
            t = t* + ;
        }
    }
}

int n, P, L, ans, f;

struct node
{
    int a,b;
} s[N];

int cmp(node n1,node n2)
{
    return n1.a<n2.a;
}

void slove()
{
    memset(Max_Heap, -, sizeof(Max_Heap));

    Max_Heap[] = INF;

    K = ;

    int pos = , i = ;

    while(i <= n)
    {
        int d = s[i].a - pos;

        while(K!= && P < d)
        {
            int p = Max_Heap[];
            Pop();
            P += p;
            ans ++;
        }
        if(P >= d)
        {
            Push(s[i].b);
            pos = s[i].a;
            P -= d;
        }
        else
        {
            ans = -;
            return ;
        }
        i ++;
    }
}

int main()
{
    int i;

    while(scanf("%d",&n) != EOF)
    {
        memset(s, , sizeof(s));

        ans=;

        for(i=; i<n; i++)
            scanf("%d %d",&s[i].a, &s[i].b);

        scanf("%d %d", &L, &P);

        for(i=; i<n; i++)
            s[i].a = L - s[i].a;

        s[i].a = L;
        s[i].b = ;

        sort(s, s+n+, cmp);

        slove();

        printf("%d\n", ans);
    }
    return ;
}