UVA 4080 Warfare And Logistics 战争与物流 (最短路树，变形)

 

 

 

题意：给一个无向图，n个点，m条边，可不连通，可重边，可多余边。两个问题，第一问：求任意点对之间最短距离之和。第二问：必须删除一条边，再求第一问，使得结果变得更大。

 

思路：

　　其实都是在求最短路的过程。

　　第一问可以floyd解决，也可以SSSP解决。注意是任意两个点，（a,b）和(b,a)是不同的，都要算。

　　第二问要穷举删除每条边，再求第一问。为了降低复杂度，假设用dijkstra求最短路，那么可以利用第一问中所生成的树，共n棵，每棵至多n-1条边，如果穷举的边不在该某树上，那么该树的所有路径长不变，不必计算，否则需要计算。所以需要记录路径，并将整棵树的边集存起来，同时保存每棵树的任意两点路径之和。

　　用结构体可以解决重边，问题应该不多，要注意各种细节，错了就重新打，也许更快。

　　

 

  1 #include <bits/stdc++.h>

  2 #define LL long long

  3 #define pii pair<int,int>

  4 #define INF 0x7f7f7f7f

  5 using namespace std;

  6 const int N=220;

  7 int n, m, l, edge_cnt;

  8 vector<int> vect[N];

  9 

 10 struct node

 11 {

 12     int from, to, dis,tag;

 13     node(){};

 14     node(int from,int to,int dis,int tag):from(from),to(to),dis(dis),tag(tag){};

 15 }edge[2050];

 16 

 17 void add_node(int from,int to,int dis,int tag)

 18 {

 19     edge[edge_cnt]=node(from, to, dis, tag);

 20     vect[from].push_back(edge_cnt++);

 21 }

 22 

 23 int dist[N], vis[N], path[N];

 24 LL dijkstra(int s)

 25 {

 26     memset(dist,0x7f,sizeof(dist));

 27     memset(vis,0,sizeof(vis));

 28     for(int i=0; i<=n; i++) path[i]=-1;

 29 

 30     priority_queue<pii,vector<pii>,greater<pii> >   que;

 31     dist[s]=0;

 32     que.push(make_pair(0,s));

 33 

 34     while(!que.empty())

 35     {

 36         int x=que.top().second;que.pop();

 37         if(vis[x])  continue;

 38         vis[x]=1;

 39         for(int i=0; i<vect[x].size(); i++)

 40         {

 41             node e=edge[vect[x][i]];

 42             if(e.tag>0 && dist[e.to]>dist[e.from]+e.dis )

 43             {

 44                 path[e.to]=vect[x][i];

 45                 dist[e.to]=dist[e.from]+e.dis;

 46                 que.push(make_pair(dist[e.to], e.to));

 47             }

 48         }

 49     }

 50 

 51     LL sum=0;

 52     for(int i=1; i<=n; i++ )

 53     {

 54         if(dist[i]>=INF)    sum+=l;//不可达的，按L算

 55         else    sum+=dist[i];

 56     }

 57     return sum;

 58 }

 59 

 60 LL ans1[N];

 61 int cal()

 62 {

 63     memset(ans1,0,sizeof(ans1));

 64     LL  first=0;

 65     unordered_set<int> tree[N];

 66     for(int i=1; i<=n; i++)

 67     {

 68         ans1[i]=dijkstra(i);

 69         first+=ans1[i];

 70         //收集边

 71         for(int k=1; k<=n; k++)

 72         {

 73             if(path[k]>=0)//注意如何初始化

 74             {

 75                 tree[i].insert(path[k]);

 76                 tree[i].insert(path[k]^1);

 77             }

 78         }

 79     }

 80     //另一个问

 81     LL second=0;

 82     for(int i=0; i<edge_cnt; i+=2)

 83     {

 84         edge[i].tag=edge[i+1].tag=0;

 85         LL sum=0;

 86         for(int j=1; j<=n; j++)

 87         {

 88             if( tree[j].find(i)==tree[j].end() )  //是点j的树上，要重新算

 89                 sum+=ans1[j];

 90             else

 91                 sum+=dijkstra(j);

 92         }

 93         second=max(second, sum);

 94         edge[i].tag=edge[i+1].tag=1;

 95     }

 96     printf("%lld %lld\n", first, second );//仅1个空格

 97 }

 98 

 99 int main()

100 {

101     freopen("input.txt", "r", stdin);

102     int a, b, c;

103     while(scanf("%d%d%d", &n, &m, &l)==3)

104     {

105         edge_cnt=0;

106         memset(edge,0,sizeof(edge));

107         for(int i=0; i<=n; i++) vect[i].clear();

108         for(int i=0; i<m; i++)

109         {

110             scanf("%d%d%d",&a,&b,&c);

111             if(a==b)    continue;

112             add_node(a,b,c,1);

113             add_node(b,a,c,1);

114         }

115         cal();

116     }

117     return 0;

118 }

AC代码