FZU 2271 X （Floyd）（第七届福建省大学生程序设计竞赛）

最新推荐文章于 2024-04-16 23:47:15 发布

原创最新推荐文章于 2024-04-16 23:47:15 发布 · 973 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#fzu-2271 #X #Floyd

ACM 同时被 3 个专栏收录

329 篇文章

订阅专栏

思路题

68 篇文章

订阅专栏

最短路径

34 篇文章

订阅专栏

本文介绍了一种针对完全繁荣国家X的复杂运输网络的裁剪算法。该算法旨在通过关闭某些道路来简化交通系统，同时确保城市间的最短距离不变。通过对 Floyd 算法的两次应用，该算法能有效找出可移除的最大数量的道路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

X

Problem Description
X is a fully prosperous country, especially known for its complicated transportation networks. But recently, for the sake of better controlling by the government, the president Fat Brother thinks it’s time to close some roads in order to make the transportation system more effective.

Country X has N cities, the cities are connected by some undirected roads and it’s possible to travel from one city to any other city by these roads. Now the president Fat Brother wants to know that how many roads can be closed at most such that the distance between any two cities in country X does not change. Note that the distance between city A and city B is the minimum total length of the roads you need to travel from A to B.

Input
The first line of the date is an integer T (1 <= T <= 50), which is the number of the text cases.

Then T cases follow, each case starts with two numbers N, M (1 <= N <= 100, 1 <= M <= 40000) which describe the number of the cities and the number of the roads in country X. Each case goes with M lines, each line consists of three integers x, y, s (1 <= x, y <= N, 1 <= s <= 10, x is not equal to y), which means that there is a road between city x and city y and the length of it is s. Note that there may be more than one roads between two cities.

Output
For each case, output the case number first, then output the number of the roads that could be closed. This number should be as large as possible.

See the sample input and output for more details.

Sample Input
2
2 3
1 2 1
1 2 1
1 2 2
3 3 1 2 1 2 3 1 1 3 1 Sample Output
Case 1: 2
Case 2: 0

思路：
一遍floyd找出最短路径并记录下被松弛的边，再来一遍floyd找出被松弛的边即可（重边可以先预处理掉）

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int inf=0x3f3f3f3f;
const int maxn=100+10;
int mp[maxn][maxn],mmp[maxn][maxn],vis[maxn][maxn];
int n,m;

void Floyd()
{
    for(int k=1; k<=n; ++k)
        for(int i=1; i<=n; ++i)
            for(int j=1; j<=n; ++j)
            {
                if(i==j)
                    continue;
                if(mp[i][k]<inf&&mp[k][j]<inf&&mp[i][j]>=mp[i][k]+mp[k][j])
                    mp[i][j]=mp[i][k]+mp[k][j],vis[i][j]=1;
            }
}

int main()
{
    int t,res=0;
    scanf("%d",&t);
    while(++res<=t)
    {
        memset(vis,0,sizeof(vis));
        memset(mp,inf,sizeof(mp));
        scanf("%d%d",&n,&m);
        int u,v,w,ans=0;
        for(int i=1; i<=m; ++i)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(mp[u][v]<inf)//先剪去重边
                ++ans;
            mp[u][v]=mp[v][u]=min(w,mp[u][v]);
        }
        memcpy(mmp,mp,sizeof(mmp));
        Floyd();
        for(int i=1; i<=n; ++i)
            for(int j=1; j<i; ++j)
            {
                if(mmp[i][j]==inf)
                    continue;
                if((mp[i][j]<=mmp[i][j]&&vis[i][j]))//表示i到j这条边可以被松弛，剪去
                    ++ans;
            }
        printf("Case %d: %d\n",res,ans);
    }
    return 0;
}