zoukankan      html  css  js  c++  java
  • 1281

    1281 - New Traffic System
    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
    ",__ca);
     83                 }
     84                 else
     85                 {
     86                         printf("Case %d: %d
    ",__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 }
    油!油!you@
  • 相关阅读:
    ZKEACMS 的两种发布方式
    一步一步教你如何制件 ZKEACMS 的扩展组件/插件
    三张图片看懂ZKEACMS的设计思想
    ZKEACMS 模板组件扩展
    ZKEACMS 如何使用组件自定义样式/编辑样式
    关于简单的Excel多页签底层导出_电子底账导出为例(.net core)
    Javascript中,数学方法可以分成以下几类: constans(常数)、power functions(乘方函数)、trigonometic functions(三角函数)、rounding functions(舍入函数)、random numbers(随机数字)
    AutoCAD.Net/C#.Net QQ群:193522571 对字符串进行四则运算
    AutoCAD.Net/C#.Net QQ群:193522571 利用反射将父类中的属性传递到子类中,实测效率不高
    AutoCAD.Net/C#.Net QQ群:193522571 将DataTable集合 B加入到DataTable A中,应用于两个或以上的只有单行数据的无主键的datatable的合并 Merge
  • 原文地址:https://www.cnblogs.com/zzuli2sjy/p/5719546.html
Copyright © 2011-2022 走看看