poj1724ROADS(优先队列+BFS 有条件的最短路)

http://poj.org/problem?id=1724

/*poj1724ROADS
题意是在一定的coins的限制下的最短路径；可以用Dijkstra的变形(BFS+优先队列)；
用邻接边来存储边；
松弛过程中用优先队列（边的长度短的优先）来存储边，将符合条件（coins限制）的边都加入优先队列；
直到找到延伸到最后一个顶点即可终止循环； 因为最先到达的一定是最短路径，在coins的限制条件下；
*/

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 111
int len[MAXN*MAXN],w[MAXN*MAXN],head[MAXN*MAXN],next[MAXN*MAXN],u[MAXN*MAXN],v[MAXN*MAXN];
int coin,n,m;
struct node
{
    int v,dis,cost;
    node(int _v,int _dis,int _cost)
    {
        v=_v,dis=_dis,cost=_cost;
    }
    friend bool operator <(const node&a,const node&b)
    {
        if(a.dis!=b.dis)return a.dis>b.dis;
         return a.cost>b.cost;
    }
};

int BFS()
{
    priority_queue<node> pq;
    pq.push(node(1,0,0));
    while(!pq.empty())
    {
        node tmp=pq.top();
        pq.pop();
        if(tmp.v==n)return tmp.dis;
        for(int e=head[tmp.v];e>=0;e=next[e])
        {
            if(tmp.cost+w[e]<=coin)//小于coin
            {
                pq.push(node(v[e],tmp.dis+len[e],tmp.cost+w[e]));
            }
        }

    }
    return -1;
}
int main()
{
    
    while(scanf("%d%d%d",&coin,&n,&m)==3)
    {
          memset(head,-1,sizeof(head));
          for(int i=0;i<m;i++)
          {
              scanf("%d%d%d%d",&u[i],&v[i],&len[i],&w[i]);
              next[i]=head[u[i]];
              head[u[i]]=i;
          }
          printf("%d\n", BFS());
    }
}