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 pre[MAXN], cost[MAXN][MAXN],lowcost[MAXN];
void Dijkstra(int n,int beg) {
int i,j;
for(i=0;i<n;i++)
lowcost[i]=INF,vis[i]=false,pre[i]=-1;
lowcost[beg]=0;
for( j=1;j<=n;j++) {
int k=-1;
int Min=INF;
for(i=0;i<n;i++)
if(!vis[i]&&lowcost[i]<Min)
Min=lowcost[i],k=i;
if(k==-1)break;
vis[k]=true;
for(i=0;i<n;i++)
if(!vis[i]&&lowcost[k]+cost[k][i]<lowcost[i])
lowcost[i]=lowcost[k]+cost[k][i],pre[i]=k;
}
}
int main()
{
int t,n,i,j,ans,k;
scanf("%d",&t);
for(int id=1;id<=t;id++)
{
scanf("%d",&n);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&cost[i][j]);
}
}

int flag=0;
for(i=0;i<n;i++)
{
Dijkstra(n,i);
for(j=0;j<n;j++)
{
if(lowcost[j]!=cost[i][j])
{
flag=1;
break;
}
}
if(flag==1)break;
}
printf("Case %d: ",id);
if(flag==1)
{
printf("impossible\n");
}
else
{
ans=0;
for(k=0;k<n;k++)
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(cost[i][j]==cost[i][k]+cost[k][j]&&i!=j&&k!=i&&k!=j)
{
cost[i][j]=INF;
}
}
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(!(cost[i][j]==0||cost[i][j]==INF))
{
ans++;
}
}
}
printf("%d\n",ans);
}
}
return 0;
}

HDU 4034 Graph(floyd,最短路,简单),布布扣,bubuko.com

时间: 2024-08-24 16:00:49

HDU 4034 Graph(floyd,最短路,简单)的相关文章

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

hdu 4034 Graph(深化最短路floyd)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4034 Graph Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others) Total Submission(s): 2188    Accepted Submission(s): 1101 Problem Description Everyone knows how to calculat

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

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

转载请注明出处:http://blog.csdn.net/u012860063 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4034 Graph Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others) Total Submission(s): 1650    Accepted Submission(s): 826 Problem Des

HDU 2833 WuKong(floyd最短路)

题目地址:HDU 2833 这题想到了最后是通过dis[s][t]==dis[s][i]+dis[i][j]+dis[j][t]的思路来判定是否属于最短路的一条..但是没想到可以用floyd来找最短路中的点数...最短路还是太渣了..好多性质都不会利用.. 这题的思路就是通过floyd对每两个点之间的最短路条数进行计数,然后通过上面的公式(对两条路线均要判定,都符合才说明都可以走),再找最短路中的最大点数. 代码如下: #include <iostream> #include <stdi

HDU - 4034 Graph (floyd变形)

题目大意:给出每个点之间的最短距离,问需要几条边才能形成这张图 解题思路:100个点,果断floyd,接着判断 如果dp[i][j] > dp[i][k] + dp[k][j]表示这张图构建不了,因为最短路冲突了 如果dp[i][j] == dp[i][k] + dp[k][j],就表示ij这条路可以被ik和kj取代,那么这条路就可去掉了 去掉的路记得标记...WA了好多次 #include <cstdio> #include <algorithm> using namesp

hdu 4034 逆向floyd

给出一个最短路邻接矩阵,求出构图的最小边数 正常的floyd的k放在最外面是为了防止i到j的距离被提前确定,而逆向的floyd,i到j的距离已经确定,所以需要在i到j之间枚举k 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 1 #include<stdio.h> 2 const int

HDU 1385 Minimum Transport Cost(Floyd 最短路 打印路径)

HDU 1385 大意: 有N个城市,然后直接给出这些城市之间的邻接矩阵,矩阵中-1代表那两个城市无道路相连,其他值代表路径长度. 如果一辆汽车经过某个城市,必须要交一定的钱(可能是过路费). 现在要从a城到b城,花费为路径长度之和,再加上除起点与终点外所有城市的过路费之和. 求最小花费,如果有多条路经符合,则输出字典序最小的路径. 思路: Floyd求最短路,打印路径即可. 1 /*--------------------------------------------------------