ROADS+dijkstra的灵活运用+POJ

ROADS

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 10742		Accepted: 3949

Description

N cities named with numbers 1 ... N are connected with one-way roads. Each road has two parameters associated with it : the road length and the toll that needs to be paid for the road (expressed in the number of coins). 
Bob and Alice used to live in the city 1. After noticing that Alice was cheating in the card game they liked to play, Bob broke up with her and decided to move away - to the city N. He wants to get there as quickly as possible, but he is short on cash. 

We want to help Bob to find the shortest path from the city 1 to the city N that he can afford with the amount of money he has. 

Input

The first line of the input contains the integer K, 0 <= K <= 10000, maximum number of coins that Bob can spend on his way. 
The second line contains the integer N, 2 <= N <= 100, the total number of cities. 

The third line contains the integer R, 1 <= R <= 10000, the total number of roads. 

Each of the following R lines describes one road by specifying integers S, D, L and T separated by single blank characters : 

• S is the source city, 1 <= S <= N 
  
• D is the destination city, 1 <= D <= N 
  
• L is the road length, 1 <= L <= 100 
  
• T is the toll (expressed in the number of coins), 0 <= T <=100

Notice that different roads may have the same source and destination cities.

Output

The first and the only line of the output should contain the total length of the shortest path from the city 1 to the city N whose total toll is less than or equal K coins. 
If such path does not exist, only number -1 should be written to the output. 

Sample Input

5
6
7
1 2 2 3
2 4 3 3
3 4 2 4
1 3 4 1
4 6 2 1
3 5 2 0
5 4 3 2

Sample Output

11

解决方式：此题我是这样做的，用上优先队列，在费用可行的情况下，不断松弛路径。事实上也相当于bfs+优先队列。首先路径最短的优先级最高，其次是花费，通过不断的把符合费用要求能到达的点增加优先队列，每次出队即更新能到达的点。最后假设出队的点是N，算法结束，得到的路径既是在花费符合的情况下最短的，这题考察的是能不能深刻理解dijkstra的原理，并运用。

code:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define MMAX 10003
#define Max 103
using namespace std;
int K,N,R,k;
int head[Max];
struct edge
{

    int from,to,len,cost;
    int next;
} E[MMAX];
struct stay
{

    int dis,cost,x;
    bool operator<(const stay &s)const
    {
        if(dis!=s.dis)
        {
            return dis>s.dis;
        }
        else return cost>s.cost;

    }

};
void add(int from,int to,int len,int cost)
{
    E[k].from=from;
    E[k].to=to;
    E[k].len=len;
    E[k].cost=cost;
    E[k].next=head[from];
    head[from]=k++;

}
int dijkstra()
{
    priority_queue<stay> Q;
    stay in;
    in.dis=0,in.cost=0,in.x=1;
    Q.push(in);
    while(!Q.empty())
    {
        stay out=Q.top();

        if(out.x==N) {return out.dis;}
        Q.pop();
        for(int v=head[out.x]; v!=-1; v=E[v].next)
        {
            if(out.cost+E[v].cost<=K)
            {
               stay temp;
               temp.x=E[v].to;
               temp.dis=out.dis+E[v].len;
               temp.cost=out.cost+E[v].cost;
               Q.push(temp);
            }
        }
    }

}
int main()
{
    while(~scanf("%d%d%d",&K,&N,&R))
    {
        memset(head,-1,sizeof(head));
        k=0;
        int from,to,len,cost;
        for(int i=0; i<R; i++)
        {
            scanf("%d%d%d%d",&from,&to,&len,&cost);
            add(from,to,len,cost);
        }
        printf("%d
",dijkstra());

    }
    return 0;
}