POJ1724(dijkstra,限制)

题目

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

• 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

题意

给定一个有 距离 和 费用 两个边权的无向图
求费用不超过k的情况下从1到N的最短路

思路

使用的是dijkstra，不过变化是不用vis排除搜索过的点，而是将每次都符合费用条件的点全部都加入优先队列中，其他就没有什么变化了，每次取出符合费用且距离最短的点，第一次访问到N点时即是符合费用的最短路

堆优化的dijkstra

常规的dij是遍历所有点N-1次，每次都找到当前距离最小的点，再更新这个点到其他联通的点的距离，使用堆优化后在找最小距离的点时则是通过维护堆完成的，复杂度从O(N)到O(logN)

代码

#include<cstdio>
#include<cstring>
#include<queue>
//#include <bits/stdc++.h>
using namespace std;

const int INF = 0x3f3f3f3f;

struct node{
    int v,dis,cost;
    bool friend operator < (const node &a,const node &b) {
        return b.dis<a.dis;
    }
    node(int v,int dis,int cost) {
        this->v=v;
        this->dis=dis;
        this->cost=cost;
    }
} temp(1,0,0);

struct Edge {
    int v,dis,cost;
    int next;
};

Edge edge[10005];
int head[105],edges;
int n,k;
int ans=INF;

void AddEdge(int u,int v,int dis,int cost) {
    edge[edges].v=v,edge[edges].dis=dis,edge[edges].cost=cost;
    edge[edges].next=head[u],head[u]=edges++;
}

void dijkstra() {
    priority_queue<node>q;
    q.push(node(1,0,0));

    while(!q.empty()) {
        temp=q.top();
        q.pop();

        if(temp.v==n) {
            ans=temp.dis;
            break;
        }

        for(int i=head[temp.v]; i!=-1 ; i=edge[i].next) {
            if(temp.cost+edge[i].cost<=k){
            	q.push( node(edge[i].v, edge[i].dis+temp.dis, edge[i].cost+temp.cost));
			}
        }
    }
}

int main()
{
    int u,v,d,c,m;
    scanf("%d%d%d",&k,&n,&m);
    edges=0;
    memset(head,-1,sizeof(head));
    while(m--) {
        scanf("%d%d%d%d",&u,&v,&d,&c);
        AddEdge(u,v,d,c);
    }
    dijkstra();

    if(ans==INF)
        printf("-1\n");
    else
        printf("%d\n",ans);

    return 0;
}