X FZU - 2271（floyd）

X

FZU - 2271

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算法进行稍加修改加几个判断即可
code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
int n,m;
int G[200][200],vis[200][200],used[200][200];
int main(){
    int t,cas = 0;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        memset(vis,0,sizeof(vis));
        memset(G,INF,sizeof(G));
        memset(used,0,sizeof(used));
        for(int i = 1; i <= n; i++){
            G[i][i] = 0;
        }
        int ans = 0;
        for(int i = 0; i < m; i++){
            int u,v,d;
            scanf("%d%d%d",&u,&v,&d);
            G[u][v] = min(G[u][v],d);//存下最小的
            G[v][u] = min(G[v][u],d);
            if(vis[u][v]) ans++;//如果这两点间有了边多出来的都是要删除的
            vis[u][v] = vis[v][u] = 1;
        }
        //floyd
        for(int k = 1; k <= n; k++){
            for(int i = 1; i <= n; i++){
                for(int j = 1; j <= n; j++){
                    if(k != i && k != j && G[i][j] >= G[i][k] + G[k][j]){
                        //k!=i,k!=j是因为这样其中一个长度是0即G[i][i]或G[j][j]从自己到自己
                        //所以另一条边其实就是G[i][j]这条边本身，并不是松弛过来的，所以为了避免重复删边加上判断
                        //并且这里是>=号因为如果有相等的长度的边，除了本身外，也要删除
                        G[i][j] = G[i][k] + G[k][j];//更新
                        if(vis[i][j] && !used[i][j]){//如果这条边存在并且还没被删就删掉（标记）
                            used[i][j] = 1;
                            used[j][i] = 1;
                            ans++;
                        }
                    }
                }
            }
        }
        printf("Case %d: %d\n",++cas,ans);
    }
    return 0;
}