【POJ3411】-Paid Roads 搜索剪枝

Time Limit: 1000MS Memory Limit: 65536K

Description

A network of m roads connects N cities (numbered from 1 to N). There may be more than one road connecting one city with another. Some of the roads are paid. There are two ways to pay for travel on a paid road i from city ai to city bi:

in advance, in a city ci (which may or may not be the same as ai);

after the travel, in the city bi.

The payment is Pi in the first case and Ri in the second case.

Write a program to find a minimal-cost route from the city 1 to the city N.

Input

The first line of the input contains the values of N and m. Each of the following m lines describes one road by specifying the values of ai, bi, ci, Pi, Ri (1 ≤ i ≤ m). Adjacent values on the same line are separated by one or more spaces. All values are integers, 1 ≤ m, N ≤ 10, 0 ≤ Pi , Ri ≤ 100, Pi ≤ Ri (1 ≤ i ≤ m).

Output

The first and only line of the file must contain the minimal possible cost of a trip from the city 1 to the city N. If the trip is not possible for any reason, the line must contain the word ‘impossible’.

Sample Input

4 5

1 2 1 10 10

2 3 1 30 50

3 4 3 80 80

2 1 2 10 10

1 3 2 10 50

Sample Output

110

Source

Northeastern Europe 2002, Western Subregion

题意：有n个城市，m条道路（有向），对与一条道路有两种状态，如果经过c花费为p，没有经过花费为r，求从1到n的最少的花费。

思路：路是有向的，并且对于同一条路我们是可以重复走的，那么重复走的原因是由于可以开启新的点，使得总的花费最短，那么我们可以限制一条路走的次数，每一次重复走与点有关，我们可以限制走的次数不超过点的个数。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;

typedef struct node
{
int c,p,r;
}Ro;

Ro R[150];

int n,m;

int u,v;

vector<pair<int,int> >E[110];

int visp[110],visr[110];

int ans;

void dfs(int u,int len)
{
if(len>ans)
{
return ;
}
if(u == n)
{
ans = min(ans,len);

return ;
}
for(int i = 0;i<E[u].size();i++)
{
if(visr[E[u][i].second]<n)
{
visr[E[u][i].second]++;

if(!visp[R[E[u][i].second].c])
{
visp[E[u][i].first] ++;

dfs(E[u][i].first,len+R[E[u][i].second].r);
}
else
{
visp[E[u][i].first] ++;

dfs(E[u][i].first,len+R[E[u][i].second].p);
}

visr[E[u][i].second]--;

visp[E[u][i].first] --;

}
}
}

int main()
{
while(~scanf("%d %d",&n,&m))
{
for(int i = 1;i<=n;i++)
{
E[i].clear();
}

for(int i = 0;i<m;i++)
{
scanf("%d %d",&u,&v);

scanf("%d %d %d",&R[i].c,&R[i].p,&R[i].r);

E[u].push_back(make_pair(v,i));
}

memset(visp,0,sizeof(visp));

memset(visr,0,sizeof(visr));

visp[1] = 1;

ans = INF;

dfs(1,0);

if(ans == INF)
{
printf("impossible\n");
}
else printf("%d\n",ans);
}
return 0;
}