六度分离(floyd算法+dijskra+SPFA)
六度分离
Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5411 Accepted Submission(s): 2195
Lele对这个理论相当有兴趣,于是,他在HDU里对N个人展开了调查。他已经得到了他们之间的相识关系,现在就请你帮他验证一下“六度分离”是否成立吧。
对于每组测试,第一行包含两个整数N,M(0<N<100,0<M<200),分别代表HDU里的人数(这些人分别编成0~N-1号),以及他们之间的关系。
接下来有M行,每行两个整数A,B(0<=A,B<N)表示HDU里编号为A和编号B的人互相认识。
除了这M组关系,其他任意两人之间均不相识。
#include<stdio.h>
int map[][];
int main(){
int N,M,flot,p1,p2;
while(~scanf("%d%d",&N,&M)){
for(int i=;i<N;++i)for(int j=;j<N;++j)if(i!=j)map[i][j]=map[j][i]=;else map[i][j]=;
while(M--){
scanf("%d%d",&p1,&p2);
map[p1][p2]=map[p2][p1]=;
}
for(int i=;i<N;++i){
for(int j=;j<N;++j){
for(int k=;k<N;++k){
map[j][k]=map[j][i]+map[i][k]<map[j][k]?map[j][i]+map[i][k]:map[j][k];
}
}
}flot=;
for(int i=;i<N;++i){
for(int j=;j<N;++j){
if(map[i][j]>){//最开始的匹配多了一所以是大于7
flot=;break;
}
}
if(!flot)break;
}
if(flot)puts("Yes");
else puts("No");
}
return ;
}
dijkscra:
#include<stdio.h>
#include<string.h>
#define MIN(x,y)(x<y?x:y)
const int INF=0x3f3f3f3f;
const int MAXN=;
int map[MAXN][MAXN];
int vis[MAXN],d[MAXN];
int N,M,ans;
void initial(){
memset(d,INF,sizeof(d));
memset(vis,,sizeof(vis));
ans=;
}
int dijskra(int s,int e){
initial();
d[s]=;
int k;
while(true){
k=-;
for(int i=;i<N;i++){
if(!vis[i]&&(k==-||d[i]<d[k]))k=i;
}
if(k==-)break;
vis[k]=;
for(int i=;i<N;i++){
d[i]=MIN(d[i],d[k]+map[k][i]);
}
}
return d[e];
}
int main(){
int a,b;
while(~scanf("%d%d",&N,&M)){
memset(map,INF,sizeof(map));
while(M--){
scanf("%d%d",&a,&b);
map[b][a]=map[a][b]=;
}
for(int i=;i<N;i++){
for(int j=i+;j<N;j++){
if(dijskra(i,j)>){
ans=;break;
}
}
if(!ans)break;
}
if(ans)puts("Yes");
else puts("No");
}
return ;
}
并查集求深度,但是wa。。。。
代码:
#include<stdio.h>
#include<string.h>
const int MAXN=;
int pre[MAXN];
int dep[MAXN];
int N,flot;
void initial(){
for(int i=;i<N;i++){
pre[i]=i;
dep[i]=;
}
flot=;
}
int find(int x){
int temp=pre[x];
if(x==pre[x])return x;
pre[x]=find(pre[x]);
dep[x]+=dep[temp];
return pre[x];
}
void merge(int x,int y){
int f1,f2;
f1=find(x);f2=find(y);
// printf("%d %d\n",f1,f2);
if(f1!=f2){
pre[f2]=f1;
dep[f1]++;
}
}
int main(){
int M;
int a,b;
while(~scanf("%d%d",&N,&M)){
initial();
while(M--){
scanf("%d%d",&a,&b);
merge(a,b);
}
for(int i=;i<N;i++){
printf("%d",dep[i]);
if(dep[i]>)flot=;
}
if(flot)puts("Yes");
else puts("No");
}
return ;
}
SPFA:
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=;
const int MAXM=;
int head[MAXM];
int dis[MAXN],vis[MAXN],used[MAXN];
queue<int >dl;
struct Edge{
int from,to,value,next;
};
Edge edg[MAXM];
int N,M,ednum,flot;
void initial(){
while(!dl.empty())dl.pop();
memset(dis,INF,sizeof(dis));
memset(used,,sizeof(used));
}
void add(int u,int v,int value){
Edge E={u,v,value,head[u]};
edg[ednum]=E;
head[u]=ednum++;
}
void get(){
int a,b,c;
while(M--){
scanf("%d%d",&a,&b);
add(a,b,);
add(b,a,);
}
}
void SPFA(int sx){
initial();
dis[sx]=;vis[sx]=;
dl.push(sx);
while(!dl.empty()){
int k=dl.front();
dl.pop();
vis[k]=;
for(int i=head[k];i!=-;i=edg[i].next){
int v=edg[i].to;
if(dis[k]+edg[i].value<dis[v]){
dis[v]=dis[k]+edg[i].value;
if(!vis[v]){
vis[v]=;
dl.push(v);
}
}
}
}
} int main(){
while(~scanf("%d%d",&N,&M)){
flot=;
memset(head,-,sizeof(head));
ednum=;
get();
// SPFA(0);
//for(int i=0;i<N;i++)printf("%d ",dis[i]);puts("");
for(int i=;i<N;i++){
SPFA(i);
for(int j=;j<N;j++){
if(dis[j]>){
flot=;break;
}
}
}
if(flot)puts("Yes");
else puts("No");
}
return ;
}
六度分离(floyd算法+dijskra+SPFA)的更多相关文章
- SPFA和FLOYD算法如何打印路径
早晨碰到了一题挺裸的最短路问题需要打印路径:vijos1635 1.首先说说spfa的方法: 其实自己之前打的最多的spfa是在网格上的那种,也就是二维的 一维的需要邻接表+queue 以及对于que ...
- HDOJ 2544 最短路(最短路径 dijkstra算法,SPFA邻接表实现,floyd算法)
最短路 Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submis ...
- 最短路-SPFA算法&Floyd算法
SPFA算法 算法复杂度 SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称,通常用于求含负权边的单源最短路径,以及判负权环. SPFA一般情况复杂度是O(m)最坏情况下复杂度和朴素 ...
- hdu 六度分离 floyd
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1869 题意分析:比较简单的最短路算法,最后只需判断最远两点距离是否大于7即可. /*六度分离 Time ...
- 【最短路径Floyd算法详解推导过程】看完这篇,你还能不懂Floyd算法?还不会?
简介 Floyd-Warshall算法(Floyd-Warshall algorithm),是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,与Dijkstra算法类似.该算法名称以 ...
- 数据结构与算法--最短路径之Bellman算法、SPFA算法
数据结构与算法--最短路径之Bellman算法.SPFA算法 除了Floyd算法,另外一个使用广泛且可以处理负权边的是Bellman-Ford算法. Bellman-Ford算法 假设某个图有V个顶点 ...
- 最短路径——Floyd算法(含证明)
通过dij,ford,spfa等算法可以快速的得到单源点的最短路径,如果想要得到图中任意两点之间的最短路径,当然可以选择做n遍的dij或是ford,但还有一个思维量较小的选择,就是floyd算法. 多 ...
- [Python] 弗洛伊德(Floyd)算法求图的直径并记录路径
相关概念 对于一个图G=(V, E),求图中两点u, v间最短路径长度,称为图的最短路径问题.最短路径中最长的称为图的直径. 其中,求图中确定的某两点的最短路径算法,称为单源最短路径算法.求图中任意两 ...
- 关于 Bellman-Ford 与 Floyd 算法的一点感想
在四种常用的最短路算法 Dijkstra, SPFA, floyd, Bellman-Ford 中, Dijks 和 SPFA 的使用较为普遍, 对大多数人来说, 也较为熟悉. 然而, floyd 与 ...
随机推荐
- [Regex Expression] Tagline --- {0, } {1,10}
Using a character set repeated 1 or more times, make a pattern to search for strings that do not con ...
- Git服务器 gitweb与gitLab的区别
昨天我们已经把Git服务器搭建完成了,工程的上传与下载都可以了,不过有些人不喜欢使用git命令进行操作.所以我们就搭建一个可视化操作的环境!配置gitweb和gitlab两种访问方式! 一,配置git ...
- 大到可以小说的Y组合子(二)
问:上一回,你在最后曾提到"抽象性不足",这话怎么说? 答:试想,如果现在需要实现一个其它的递归(比如:Fibonacci),就必须把之前的模式从头套一遍,然后通过fib_make ...
- SQL Server 阻止了对组件 'Ad Hoc Distributed Queries' 的 STATEMENT'OpenRowset/OpenDatasource' 的访问的解决方案
今天写了一个excel表的导入功能,结果在excel表中的内容导入到页面时报错:SQL Server 阻止了对组件 'Ad Hoc Distributed Queries' 的 STATEMENT ...
- js keycode 列表
keycode 8 = BackSpace BackSpace keycode 9 = Tab Tab keycode 12 = Clear keycode 13 = Enter ...
- table-cell完成左侧定宽,右侧定宽及左右定宽等布局
使用table-cell完成以下几种布局(ie8及以上兼容) 1.左侧定宽-右侧自适应 .left{ width: 300px; height: 500px; border: 1px solid; f ...
- magic Ajax使用以及注意事项
以下是引用片段:一.概述 现在Ajax技术正如火如荼的在Internet上发展着.而面对我们之前开发的ASP.NET1.1的Web项目,类似于下拉框等联动也需要啪啪啪的不断刷新,的确影响到了用户 ...
- TortoiseSVN和VisualSVN-下载地址
isualSVN的下载地址http://www.visualsvn.com/visualsvn/ 它可以以插件的形式嵌入到visual studio里面,让团队协作更轻松,最新的版本已经支持Visua ...
- ORA-00937:不是单组分组函数_Oracle
Demo: SELECT USER_ID, USER_NAME, USER_SEX, MAX(USER_AGE), SUM(USER_MONEY) AS USER_MONEY USER_TEL, US ...
- ubuntu 16.04 下载源
修改适当的更新源 可以使得aptget安装的速度变得快很多 ubuntu的更新源在 /etc/apt/sources.list 修改更新源 sudo vi /etc/apt/sources.list ...