hdu4034 Graph(floyd)

题目:  给出一个图的最短路,求原图最少几条边

Graph

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others)
Total Submission(s): 1695    Accepted Submission(s): 848

Problem Description

Everyone knows how to calculate the shortest path in a directed graph. In fact, the opposite problem is also easy. Given the length of shortest path between each pair of vertexes, can you find the original graph?

Input

The first line is the test case number T (T ≤ 100).
First line of each case is an integer N (1 ≤ N ≤ 100), the number of vertexes.
Following N lines each contains N integers. All these integers are less than 1000000.
The jth integer of ith line is the shortest path from vertex i to j.
The ith element of ith line is always 0. Other elements are all positive.

Output

For each case, you should output “Case k: ” first, where k indicates the case number and counts from one. Then one integer, the minimum possible edge number in original graph. Output “impossible” if such graph doesn‘t exist.

Sample Input

3
3
0 1 1
1 0 1
1 1 0
3
0 1 3
4 0 2
7 3 0
3
0 1 4
1 0 2
4 2 0

Sample Output

Case 1: 6
Case 2: 4
Case 3: impossible

Source

The 36th ACM/ICPC Asia Regional Chengdu Site —— Online Contest

先假设每两个点之间都有边,ans = n*(n-1), 然后用floyd , 对于 i,j , 以k为中点,如果 dist[i][j] == dist[i][k]+dist[k][j] 说明这条路可以被替代,减去一条边。

反之如果大于的话,就和题目的最短路矛盾了。 输出impossible

代码:

 1 #include <iostream>
 2 #include <sstream>
 3 #include <ios>
 4 #include <iomanip>
 5 #include <functional>
 6 #include <algorithm>
 7 #include <vector>
 8 #include <string>
 9 #include <list>
10 #include <queue>
11 #include <deque>
12 #include <stack>
13 #include <set>
14 #include <map>
15 #include <cstdio>
16 #include <cstdlib>
17 #include <cmath>
18 #include <cstring>
19 #include <climits>
20 #include <cctype>
21 using namespace std;
22 #define XINF INT_MAX
23 #define INF 0x3FFFFFFF
24 #define MP(X,Y) make_pair(X,Y)
25 #define PB(X) push_back(X)
26 #define REP(X,N) for(int X=0;X<N;X++)
27 #define REP2(X,L,R) for(int X=L;X<=R;X++)
28 #define DEP(X,R,L) for(int X=R;X>=L;X--)
29 #define CLR(A,X) memset(A,X,sizeof(A))
30 #define IT iterator
31 typedef long long ll;
32 typedef pair<int,int> PII;
33 typedef vector<PII> VII;
34 typedef vector<int> VI;
35
36 int N;
37 int dist[105][105];
38 int vis[105][105];
39 int main()
40 {
41     ios::sync_with_stdio(false);
42
43     int tst;
44     cin>>tst;
45     int cse = 0;
46     while(tst--)
47     {
48         CLR(dist,0);CLR(vis,0);
49
50         cin>>N;
51         REP(i,N)
52         REP(j,N)
53         {
54             cin>>dist[i][j];
55         }
56         cout<<"Case "<<++cse<<": ";
57
58         int ans = N*(N-1);
59         REP(k,N)
60         {
61             REP(i,N)
62             {
63                 REP(j,N)
64                 {
65                     if( i == k || j == k)continue;
66                     if(!vis[i][j] && dist[i][j] == dist[i][k]+dist[k][j])
67                     {
68                         ans--;
69                         vis[i][j] =1;
70                     }
71                     if( dist[i][j] > dist[i][k]+dist[k][j])
72                     {
73                         ans = -1;
74                         break;
75                     }
76                 }
77                 if( ans ==-1)
78                 {
79                     break;
80                 }
81             }
82             if(ans==-1)break;
83         }
84         if( ans == -1)
85         {
86             cout<<"impossible"<<endl;
87         }
88         else
89         {
90             cout<<ans<<endl;
91         }
92
93     }
94
95     return 0;
96 }

hdu4034 Graph(floyd),布布扣,bubuko.com

时间: 2024-10-03 19:37:47

hdu4034 Graph(floyd)的相关文章

HDU 4034 Graph(floyd,最短路,简单)

题目 一道简单的倒着的floyd. 具体可看代码,代码可简化,你有兴趣可以简化一下,就是把那个Dijsktra所实现的功能放到倒着的floyd里面去. #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; const int MAXN=110; const int INF=0x3f3f3f3f;//防止后面溢出,这个不能太大 bool vis[MAXN]; int pr

Greg and Graph+floyd算法的应用

Greg and Graph time limit per test 3 seconds memory limit per test 256 megabytes input standard input output standard output Greg has a weighed directed graph, consisting of n vertices. In this graph any pair of distinct vertices has an edge between

hdu 4034 Graph (floyd的深入理解)

Graph Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others)Total Submission(s): 1927    Accepted Submission(s): 965 Problem Description Everyone knows how to calculate the shortest path in a directed graph. In fact, the

HDU 4034 Graph Floyd最短路

原题链接:http://acm.hdu.edu.cn/showproblem.php?pid=4034 题意: 给你一个最短路的表,让你还原整个图,并使得边最少 题解: 这样想..这个表示通过floyd得到的,那么如果从u到v没有小于等于边(u,v)的路径,那么边(u,v)就是必须的,否则从u到v需要走更远的路.如果有路径和边(u,v)是一样的,那么边(u,v)就是不需要的,这是因为,任何需要从u到v的路径都可以用另外一条代替.如果有小于边(u,v)的,那么这就是个非法的最短路表. 代码: #i

codeforces 295B B. Greg and Graph(floyd+dp)

题目链接: codeforces 295B 题目大意: 给出n个点的完全有权有向图,每次删去一个点,求每次操作前整张图各个点的最短路之和. 题目分析: 首先删边对于我们来说是不好做的,所以我们想到了通过加点的方式逆向地做,那么加点怎么做呢? 其实就是一个我们很熟悉的算法:floyd,因为我们通常用的都是它的简化版本,所以可能很多人并不理解它的确切的思想. 在介绍这道题的具体解法之前,我先解释一下floyd,可能之后的问题就迎刃而解了. 首先floyd其实是动态规划,没有省略时的状态是这样定义的.

295B - Greg and Graph (floyd逆序处理)

题意:给出任意两点之间的距离,然后逐个删除这些点和与点相连的边,问,在每次删除前的所有点对的最短距离之和 分析:首先想到的是floyd,但是如果从前往后处理,复杂度是(500)^4,超时,我们从后往前处理,这样我们可以看作是添加点,而且这样的话每次只需要考虑添加点的缩进,所以复杂度是(500)^3,注意,我们每次添加一个点,就给他一个标记,代表这个点已经添加,然后算距离的时候,只有添加过的点才能加上距离 代码: #include <bits/stdc++.h> using namespace

HDU 4034 Graph Floyd变形

戳这里:HDU 4034 //思路:根据题意可得,若 mat[i][j] > mat[i][k] + mat[k][j] 则无解;若 mat[i][j] == mat[i][k] + mat[k][j] 且分别对应 i->j  i->k  k->j 的三条有向边,则可以删掉 i->j 有向边使得原来 i 到 j 的最短路径不发生变化; 那么我们将输入的邻接矩阵当成一个有向完全图,不断的删除多余的边,得到只含最少边的最优解.实现起来要注意删边操作对判无解操作的影响 1 #inc

数据结构:点对之间最短距离--Floyd算法

Floyd算法 Floyd算法 Dijkstra算法是用于解决单源最短路径问题的,Floyd算法则是解决点对之间最短路径问题的.Floyd算法的设计策略是动态规划,而Dijkstra采取的是贪心策略.当然,贪心算法就是动态规划的特例. 算法思想 点对之间的最短路径只会有两种情况: 两点之间有边相连,weight(Vi,Vj)即是最小的. 通过另一点:中介点,两点相连,使weight(Vi,Vk)+weight(Vk,Vj)最小. Min_Distance(Vi,Vj)=min{weight(Vi

最短路径问题---Floyd算法详解

前言 Genius only means hard-working all one's life. Name:Willam Time:2017/3/8 1.最短路径问题介绍 问题解释: 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径 解决问题的算法: 迪杰斯特拉算法(Dijkstra算法) 弗洛伊德算法(Floyd算法) SPFA算法 之前已经对Dijkstra算法做了介绍(不懂的可以看这篇博客:Dijkstra算法详解),所以这篇博客打算对Floyd算法做