| PDF (English) | Statistics | Forum |
| Time Limit: 2 second(s) | Memory Limit: 32 MB |
The country - Ajobdesh has a lot of problems in traffic system. As the Govt. is very clever (!), they made a plan to use only one way roads. Two cities s and t are the two most important cities in the country and mostly people travel from s to t. That‘s why the Govt. made a new plan to introduce some new one way roads in the traffic system such that the time to travel from s to t is reduced.
But since their budget is short, they can‘t construct more than d roads. So, they want to construct at most d new roads such that it becomes possible to reach t from s in shorter time. Unluckily you are one living in the country and you are assigned this task. That means you will be given the existing roads and the proposed new roads, you have to find the best path from s to t, which may allow at most d newly proposed roads.
Input
Input starts with an integer T (≤ 30), denoting the number of test cases.
Each case starts with a line containing four integers n (2 ≤ n ≤ 10000), m (0 ≤ m ≤ 20000), k (0 ≤ k ≤ 10000), d (0 ≤ d ≤ 10) where n denotes the number of cities, m denotes the number of existing roads and k denotes the number of proposed new roads. The cities are numbered from 0 to n-1 and city 0 is denoted as s and city (n-1) is denoted as t.
Each of the next m lines contains a description of a road, which contains three integers ui vi wi (0 ≤ ui, vi < n, ui ≠ vi, 1 ≤ wi ≤ 1000) meaning that there is a road from ui to vi and it takes wi minutes to travel in the road. There is at most one road from one city to another city.
Each of the next k lines contains a proposed new road with three integers ui vi wi (0 ≤ ui, vi < n, ui ≠ vi 1 ≤ wi ≤ 1000) meaning that the road will be from ui to vi and it will take wi minutes to travel in the road. There can be at most one proposed road from one city to another city.
Output
For each case, print the case number and the shortest path cost from s to t or "Impossible" if there is no path from s to t.
Sample Input |
Output for Sample Input |
|
2 4 2 2 2 0 1 10 1 3 20 0 2 5 2 3 14 2 0 1 0 0 1 100 |
Case 1: 19 Case 2: Impossible |
Note
Dataset is huge, use faster I/O methods.
思路：最短路；
这个是二维最短路，因为可以添加一些边，而且边数有限制，d[i][j]表示到0点到当前点添加条边的最短路径，用个优先队列维护的dj算法。
其实我感觉会暴的，不过还是过了。
1 #include <cstdio>
2 #include <cstdlib>
3 #include <cstring>
4 #include <cmath>
5 #include <iostream>
6 #include <algorithm>
7 #include <map>
8 #include <queue>
9 #include <vector>
10 using namespace std;
11 typedef long long LL;
12 typedef struct pp
13 {
14 int from;
15 int to;
16 int cost;
17 int time;
18 bool operator<(const pp&cx)const
19 {
20 return cx.cost<cost;
21 }
22 } ss;
23 vector<ss>vec[20005];
24 vector<ss>avec[20005];
25 int dis[11][20000];
26 priority_queue<ss>que;
27 bool flag[11][20000];
28 ss mark[20000];
29 void dj(int p);
30 int main(void)
31 {
32 int i,j,k;
33 int __ca=0;
34 scanf("%d",&k);
35 int n,m,s,d;
36 while(k--)
37 {
38 __ca++;
39 scanf("%d %d %d %d",&n,&m,&s,&d);
40 for(i=0; i<20000; i++)
41 {
42 mark[i].time=0;
43 mark[i].cost=1e9;
44 }
45 while(!que.empty())
46 que.pop();
47 for(i=0; i<20005; i++)
48 {
49 vec[i].clear();
50 avec[i].clear();
51 }
52 while(m--)
53 {
54 int x,y,co;
55 scanf("%d %d %d",&x,&y,&co);
56 ss aa;
57 aa.from=x;
58 aa.to=y;
59 aa.cost=co;
60 vec[x].push_back(aa);
61 }
62 for(i=0; i<s; i++)
63 {
64 int x,y,co;
65 scanf("%d %d %d",&x,&y,&co);
66 ss aa;
67 aa.from=x;
68 aa.to=y;
69 aa.cost=co;
70 avec[x].push_back(aa);
71 }
72 memset(flag,0,sizeof(flag));
73 dj(d);
74 int maxx=1e9;
75 for(i=0; i<=d; i++)
76 {
77 if(maxx>dis[i][n-1])
78 maxx=dis[i][n-1];
79 }
80 if(maxx==1e9)
81 {
82 printf("Case %d: Impossible\n",__ca);
83 }
84 else
85 {
86 printf("Case %d: %d\n",__ca,maxx);
87 }
88 }
89 return 0;
90 }
91 void dj(int p)
92 {
93 int i,j;
94 for(i=0; i<11; i++)
95 {
96 for(j=0; j<20000; j++)
97 {
98 dis[i][j]=1e9;
99 }
100 dis[i][0]=0;
101 }
102 dis[0][0]=0;
103 ss ak;
104 ak.to=0;
105 ak.cost=0;
106 ak.time=0;
107 que.push(ak);
108 while(!que.empty())
109 {
110 ss a=que.top();
111 que.pop();
112 int to=a.to;
113 int time=a.time;
114 int co=a.cost;
115 if(dis[time][to]<co||flag[time][to])
116 continue;
117 else
118 {
119 flag[time][to]=true;
120 dis[time][to]=co;
121 for(i=0; i<vec[to].size(); i++)
122 {
123 ss ac=vec[to][i];
124 if(dis[time][ac.to]>co+ac.cost)
125 {
126 dis[time][ac.to]=co+ac.cost;
127 ss dd;
128 dd.to=ac.to;
129 dd.cost=co+ac.cost;
130 dd.time=time;
131 que.push(dd);
132 }
133 }
134 if(time<p)
135 {
136 for(i=0; i<avec[to].size(); i++)
137 {
138 ss ac=avec[to][i];
139 if(dis[time+1][ac.to]>co+ac.cost)
140 {
141 dis[time+1][ac.to]=co+ac.cost;
142 ss dd;
143 dd.to=ac.to;
144 dd.cost=co+ac.cost;
145 dd.time=time+1;
146 que.push(dd);
147 }
148 }
149 }
150 }
151 }
152 }