hdu5876（求补图的最短路，set用法）

Sparse Graph

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 653    Accepted Submission(s): 222

Problem Description

In graph theory, the complement of a graph G is a graph H on the same vertices such that two distinct vertices of H are adjacent if and only if they are not adjacent in G .

Now you are given an undirected graph G of N nodes and M bidirectional edges of unit length. Consider the complement of G , i.e., H . For a given vertex S on H , you are required to compute the shortest distances from S to all N−1 other vertices.

 

Input

There are multiple test cases. The first line of input is an integer T(1≤T<35) denoting the number of test cases. For each test case, the first line contains two integers N(2≤N≤200000) and M(0≤M≤20000) . The following M lines each contains two distinct integers u,v(1≤u,v≤N) denoting an edge. And S (1≤S≤N) is given on the last line.

 

Output

For each of T test cases, print a single line consisting of N−1 space separated integers, denoting shortest distances of the remaining N−1 vertices from S (if a vertex cannot be reached from S, output ``-1" (without quotes) instead) in ascending order of vertex number.

 

Sample Input

  
  

   
   1
2 0
1
  
  

 

Sample Output

  
  

   
   1
  
  

题意：求一个图的补图的最短路。

思路：广搜的思路很明显，由于点数太多，边数太少，所以不能直接建完全图再删边，所以直接建立原图，用广搜的方法直接求得结果。比赛的时候没用set，用的vector的删除，比较慢，总是T，看题解之后才发现得用set……set是红黑树的平衡二叉树，查找速度比较快，所以不会T，下次就不会这样T_T了。

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<map>
#include<stdlib.h>
#include<time.h>
#include<stack>
#include<set>
using namespace std;
typedef long long ll;
const int N=200010;///N表示点的最多数量
int head[N],dis[N];
int ip;
struct edge
{
    int to,next;
} tu[N*2];
void init()
{
    ip=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v)
{
    tu[ip].to=v,tu[ip].next=head[u],head[u]=ip++;
}
void bfs(int s,int n)
{
    set<int>a,b;
    for(int i=1; i<=n; i++)
    {
        dis[i]=-1;
        if(i!=s)
            a.insert(i);
    }
    dis[s]=0;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x]; i!=-1; i=tu[i].next)
            if(a.count(tu[i].to))
            {
                b.insert(tu[i].to);
                a.erase(tu[i].to);
            }
        for(set<int>::iterator i=a.begin(); i!=a.end(); i++)
        {
            q.push(*i);
            dis[*i]=dis[x]+1;
        }
        a.swap(b);
        b.clear();
    }
    for(int i=1; i<=n; i++)
        if(i!=s)
        {
            if(i==n)
                printf("%d\n",dis[i]);
            else
                printf("%d ",dis[i]);
        }
}
int main()
{
    int t;
    while(~scanf("%d",&t))
    {
        while(t--)
        {
            init();
            int n,m;
            scanf("%d%d",&n,&m);
            for(int i=0; i<m; i++)
            {
                int x,y;
                scanf("%d%d",&x,&y);
                add(x,y);
                add(y,x);
            }
            int s;
            scanf("%d",&s);
            bfs(s,n);
        }
    }
    return 0;
}