poj 1724 ROADS

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

大致题意：

给定一个图，图中每条路都有 路长Length 和 过路费Toll 两个参数，一条路连接两个城市，任意两个城市之间有且仅有一条路。

现在只有 K 块钱，要求从起点City1出发，到达终点CityN的最短路，也就是说在 K 花费内的最短路。

#include <iostream>
#include <stdio.h>
#include <string.h>
#define MM 9999999
using namespace std;
int K,N,R;
struct node
{
    int s,d,l,t,next;
}dd[10005];
bool flag[111];
int head[111];
int tot;
int Minlen;
void dfs(int pos,int len,int cost)
{
    if(pos==N)
    {
        if(cost<=K && len<Minlen)
        {
            Minlen=len;
        }
        return;
    }
    if(len>=Minlen)
    {
        return;
    }
    if(cost>K)
    {
        return;
    }
    int i;
    for(i=head[pos];i!=-1;i=dd[i].next)
    {
        if(!flag[dd[i].d])
        {
            int sd=dd[i].d;
            int sl=dd[i].l;
            int st=dd[i].t;
            flag[sd]=true;
            dfs(sd,len+sl,cost+st);
            flag[sd]=false;
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&K,&N,&R))
    {
        int i;
        tot=0;
        memset(head,-1,sizeof(head));
        for(i=0;i<R;i++)
        {
            scanf("%d%d%d%d",&dd[i].s,&dd[i].d,&dd[i].l,&dd[i].t);
            dd[i].next=head[dd[i].s];
            head[dd[i].s]=tot++;
        }
        memset(flag,false,sizeof(flag));
        flag[1]=true;
        Minlen=MM;
        dfs(1,0,0);
        if(Minlen==MM)
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",Minlen);
        }
    }
    return 0;
}

方法是使用了DFS+剪枝；

这题和POJ3411差不多，学习使用邻接矩阵方法来处理存在相同起点和终点的情况。

确实学习了，这种方法省了很多时间。