sdut Thrall’s Dream(判断任意两点是否联通)

题意:给一张无向图,判断任意两点是否联通;

思路:bfs枚举个点,逐个遍历;

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int con[2005][2005];
vector<short> v[2005];
int n,m;
int judge()
{
    int i,j;
    for(i=1;i<=n;i++)
    {
        for(j=i+1;j<=n;j++)
        {
            if(!con[i][j]&&!con[j][i]) return 0;
        }
    }
    return 1;
}
void bfs(int x)
{
    queue<short> que;
    que.push(x);
    while(!que.empty())
    {
        short temp=que.front();
        que.pop();
        if(temp<x)
        {
            for(int i=1;i<=n;i++)
            {
                if(con[temp][i])
                {
                    con[x][i]=1;
                }
            }
        }
        else
        {
            for(int i=0;i<v[temp].size();i++)
            {
                if(!con[x][v[temp][i]])
                {
                    con[x][v[temp][i]]=1;
                    que.push(v[temp][i]);//相邻点入队列
                }
            }
        }
    }
}
int main()
{
    int i,j,k,t,a,b;
    while(scanf("%d",&t)!=EOF)
    {
        for(i=1;i<=t;i++)
        {
            memset(con,0,sizeof(con));
            memset(v,0,sizeof(v));
            scanf("%d%d",&n,&m);
            for(j=0;j<m;j++)
            {
                scanf("%d%d",&a,&b);
                v[a].push_back(b);
            }
            for(k=1;k<=n;k++)
            {
                bfs(k);
            }
            printf("Case %d: ",i);
            if(judge()) printf("Kalimdor is just ahead\n");
            else printf("The Burning Shadow consume us all\n");
        }
    }
    return 0;
}
时间: 2024-11-06 04:25:38

sdut Thrall’s Dream(判断任意两点是否联通)的相关文章

SDUT 2604 Thrall’s Dream (单连通的判断)

大意:给定一些有向图间的关系问任意两点是不是可达的. 思路:Tarjan后直接看入度和出度为0的数量关系,如果大于1则肯定是不可能,相连通的. #include<map> #include<queue> #include<cmath> #include<cstdio> #include<stack> #include<iostream> #include<cstring> #include<algorithm>

[ACM] SDUT 2604 Thrall’s Dream

Thrall's Dream Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 We never paid any heed to the ancient prophecies, like fools we clung to the old hatreds, and fought as we had for generations. Until one day the sky rained fire, and a new ene

sdutoj Thrall’s Dream

http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2604 Thrall’s Dream Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 We never paid any heed to the ancient prophecies, like fools we clung to the old hatreds, and fought

Floyd-Warshall算法(求解任意两点间的最短路) 详解 + 变形 之 poj 2253 Frogger

/* 好久没有做有关图论的题了,复习一下. --------------------------------------------------------- 任意两点间的最短路(Floyd-Warshall算法) 动态规划: dp[k][i][j] := 节点i可以通过编号1,2...k的节点到达j节点的最短路径. 使用1,2...k的节点,可以分为以下两种情况来讨论: (1)i到j的最短路正好经过节点k一次 dp[k-1][i][k] + dp[k-1][k][j] (2)i到j的最短路完全

2014东北农大校赛--D.Cross the middle (任意两点最短路径 Floyd)

Cross the middle Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 36  Solved: 13 [Submit][Status][Web Board] Description n个点的图,给出任意两点之间的距离,m个询问,每次询问Mid是否可能出现在从Start到End的最短路径上. Input 第一行n,m 接下来是一个n*n的邻接矩阵,w[i][j]表示i到j的距离 接下来m行 每行start,end,mid N,m<=100,

任意两点最短路 Floyd-Warshall算法 传递闭包

Floyd-Warshall算法是求解任意两点最短路的有力武器.其也适用于存在负边的情况. DP思路,假设只使用前K个点时i到j的最短距离为d[k][i][j] 那么,使用前K+1个点就可以分成两种情况 ①i到j的最短路用到了第K+1个点(d[k+1][i][j] = d[k][i][j]) ②i到j的最短路没有用到第K+1个点(d[k+1][i][j] = d[k][i][k]+d[k][k][j]); 所以,d[k+1][i][j] = min(d[k][i][j],d[k][i][k]+d

任意两点间的最短路问题 Floyd-Warshall算法

这一算法与之前的Bellman-F=Ford算法一样,都可以判断负环 只需要检查dp [i] [j] 是负数的顶点i即可 1 // 求解任意两点间的最短路径问题 2 // Floyed-Warshall算法 3 // 复杂度O(N^3),N为顶点数 4 5 #include <cstdio> 6 #include <iostream> 7 8 using namespace std; 9 // 用dp的思路来求解 10 // dp[k][i][j]:从i到j,只利用前K个节点的最短

基于pgrouting的任意两点间的最短路径查询函数二

在前面的博文中写过一篇查询任意两点间最短路径的函数,当时对pgrouting不熟悉,功能很low.现在对该函数进行扩展,支持用户自己输入查询的数据库表,这一点看似简单,其实意义很大,在做室内导航的时候当用户所在的楼层变化的时候最短路径函数查询的数据表名称也会发生变化,不可能一栋大楼里的道路都是一样的吧,另外进行跨楼层的最短路径规划时,需要查询从A到楼梯口的最短路径和楼梯口到B的最短路径,这些都需要进行最短路径规划的时候能够自己选择数据表. DROP FUNCTION pgr_fromAtoB(t

任意两点间最短距离floyd-warshall ---- POJ 2139 Six Degrees of Cowvin Bacon

floyd-warshall算法 通过dp思想 求任意两点之间最短距离 重复利用数组实现方式dist[i][j] i - j的最短距离 for(int k = 1; k <= N; k++) for (int i = 1; i <= N; i++) for (int j = 1; j <= N; j++) dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]); 非常好实现 O(V^3) 这里贴一道刚好用到的题 http://poj.org