hdu-5876-Sparse Graph

Sparse Graph

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)

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 notadjacent 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

题意：

给定一个具有n个点，m条边的无向图G，求在其“补图”中一起点st到其余所有定点的最短距离。

题目链接：Sparse Graph

解题思路：

注意到G图中最多只有200 00条边，但定点可达2 000 00,是稀疏图，因此还原其补图H的话肯定受不了时间，

考虑枚举G图中的边，只要任意点u到v没边，那么在H中就是有边的，因此只要处理G图中有边的顶点，然后从已

经处理好的顶点Dijkstra求最短路即可，

但G图中的边少，意味着H图中很多点之间都是有边的，那么循环过程中可以很快就能求除答案，需要提前退出循

环，cnt记录还需处理的顶点个数

代码：

#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<string>
#include<cmath>
#include<iostream>
#include<map>
#include<queue>
#include<list>

using namespace std;
typedef long long LL;
const int N = 1e5;
int n, m, st;
vector<int> G[N*2+10];

struct node
{
int u, c;
node(int uu, int cc) : u(uu), c(cc) {}
node() {}
bool operator < (const node& t) const
{
return c > t.c;
}
};

void solve()
{
int path[n+10], cnt = G[st].size();//cnt为需要处理的点
for(int i = 0;i <= n;i++) {
path[i] = 1;
}
priority_queue<node> qe;
for(int i = 0,k = G[st].size();i < k;i++) {
int v = G[st][i];
path[v] = 0;                    //需要处理
}
for(int i = 1;i <= n;i++) {//从已经处理好的点开始，处理需要处理的点
if(path[i] == 1) {
qe.push(node (i,1) );
}
}
while(!qe.empty() && cnt > 0) {
node u = qe.top();
qe.pop();
for(int i = 1, j, k;i <= n;i++) if(path[i] == 0){  //因为边最多只有5500条，所以这个循环执行的次数只有几次
for(j = 0,k = G[u.u].size();j < k;j++) {  //枚举u的边
int v = G[u.u][j];
if(v == i) break;  //i点到u点在G图中有路，则在H图中无法确定
}
if(j == k) {//可以确定起点到i点的距离
path[i] = u.c+1;
cnt--;//printf("st %d i = %d c = %d cnt =%d\n",u.u,i,path[i],cnt);
qe.push(node (i,u.c+1));
}
}
}
for(int i = 1;i <= n;i++) {//输出
if(i == st) continue;
if(path[i] == 0) path[i] = -1;
printf("%d%c",path[i],i == n?'\n':' ');
}
if(st == n) printf("\n");
}

void init()
{
for(int i = 1;i <= n;i++) {
G[i].clear();
}
}

int main()
{
int T;
scanf("%d",&T);
while(T--) {
scanf("%d%d",&n,&m);
init();
int u, v;
for(int i = 0;i < m;i++) {
scanf("%d%d",&u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
scanf("%d",&st);
solve();
}
return 0;
}