poj 3697 USTC campus network

http://www.cnblogs.com/LyonLys/archive/2012/05/19/poj_3697_Lyon.html(转载请标明出处)

http://poj.org/problem?id=3697

　　poj的一道图论题。刚开始用太多STL的容器，所以TLE了2次。

　　简单描述题目的意思，USTC校园的网络是一个巨大的网络。最初，每两台计算机之间都由一条双向的网线连接着，其中一台是BBS服务器。可是，最近网络中的某些网线被破坏了，网络管理员想知道还有多少台计算机直接或间接的连接着服务器。

　　一眼看上去，这题可以用并查集来解决，但是数据规模是n=10000个点，m=1000000条边，所以如果用并查集做，时间显然是会非常长的。然后，从边的数目可以发现，这是一幅比较稀疏的无向图，因此，我们可以从边的遍历来考虑。怎么可以用到这些边呢？因为我们要知道，有多少台计算机连接着服务器，因此，我们将可以根据原来与连接的但后来损坏了的网线找出现在与服务器直接连接的计算机有哪些。同样的，对于每一台上一步中被找出的计算机，我们将可以用同样的方法找出下一批间接连接的计算机。

　　好的，现在看回上面的操作，是不是发现跟bfs十分相似呢？所以我们可以用队列储存每一个需要被检查的元素，用一个布尔数组储存元素是否曾经入队。这个布尔数组还有一个用处，就是可以在最后用于统计有多少台计算机连接着服务器，因为入队的元素都应该连接着服务器的。然而，最大的一个问题是，如果对于每一个队列中的元素都要遍历除它以外的所有计算机来找出有哪些计算机是连接着的，那么时间复杂度就是O(n^2)，这样是会超时的。但是，我们可以发现，其实我们可以只是判断那些还没被确定的计算机是否连接着服务器，所以我们需要一个set来储存那些还没确定的计算机编号，然后每次检测的时候就遍历一下这个set。初始状态是，除了服务器外，所有计算机都被加入set中。

　　于是，加上遍历端点（可能全部计算机都入队了）的时间，总的理论时间复杂度是O(n+ｍ)，应该是可以在限定的时间内解决最坏情况的。然而，为了减少代码量，我们需要用到STL的容器。刚开始，我是用set来储存断了的边，但是后来debug时发现，如果用set，在读入比个并储存1000000条边的时候就已经就已经TLE了……囧。可能是因为set用的是RBT，因此每次插入结点的时候时间常数太大了。然后，我就用了一个priority_queue数组来实现同样的功能。

　　下面是我的代码，仅供参考（注释掉的那几行是debug以及之前用set数组的代码）：

#include "cstdio"
#include "cstdlib"
#include "cstring"
#include "cmath"
#include "cctype"
#include "vector"
#include "set"
#include "map"
#include "string"
#include "algorithm"
#include "stack"
#include "queue"

#define INF 0x7fffffffffffffff
#define reset(a) memset(a, 0, sizeof(a))
#define copy(a, b) memcpy(a, b, sizeof(b))
#define FMAX (1E300)
#define MAX 1000000000
#define feq(a, b) (fabs((a)-(b))<1E-6)
#define flq(a, b) ((a)<(b)||feq(a, b))
#define MAXN 10005
#define BASE 137
#define PASS puts("pass")
#define filein freopen("test.in", "r", stdin)
#define fileout freopen("test.out", "w", stdout)
#define eps 1e-4
#define max2(a, b) ((a) > (b) ? (a) : (b))
#define min2(a, b) ((a) < (b) ? (a) : (b))

using namespace std;

//set<int> con[10001];
priority_queue<int, vector<int>, greater<int> > con[10001];
set<int> ns;
set<int>::iterator it;
bool vis[10001];
queue<int> Q;

void init(int n){
    ns.clear();
    while (Q.size())
        Q.pop();
    Q.push(1);
    for (int i = 2; i <= n; i++){
        while (con[i].size())
            con[i].pop();
        //con[i].clear();
        vis[i] = false;
        ns.insert(i);
    }
    while (con[1].size())
        con[1].pop();
    //con[1].clear();
    vis[1] = true;
    //PASS;
}

int main(){
    //filein;
    int Case = 0;
    int n, m;
    int a, b;

    while (~scanf("%d%d", &n, &m) && (m || n)){
        init(n);
        //PASS;
        while (m--){
            scanf("%d%d", &a, &b);
            con[a].push(b);
            con[b].push(a);
        }
        //PASS;
        while (Q.size()){
            int cur = Q.front();

            Q.pop();
            //PASS;
            for (it = ns.begin(); it != ns.end();){
                int i = *it;

                while (con[cur].size() && con[cur].top() < i)
                    con[cur].pop();
                //if (!con[cur].count(i)){
                if (!con[cur].size() || i != con[cur].top()){
                    if (!vis[i]){
                        Q.push(i);
                        vis[i] = true;
                    }
                    ns.erase(it++);
                }
                else
                    it++;
            }
        }

        int cnt = 0;

        for (int i = 2; i <= n; i++)
            cnt += vis[i];

        printf("Case %d: %d\n", ++Case, cnt);
    }

    return 0;
}

　　网上有些题解说是用hash表来做，但是我还没想到怎样做，应该那样子时间会少很多吧。

　　附带上我的大数据生成代码：

#include "cstdio"

#define fileout freopen("test.in", "w", stdout)

int main(){
    fileout;
    printf("10000 1000000\n");

    int cnt = 0;

    for (int i = 10; i < 10000 && cnt < 1000000; i++){
        for (int j = 1; j <= 10000 && cnt < 1000000; j++){
            printf("%d %d\n", i, j);
            cnt++;
        }
    }

    return 0;
}

 

——written by Lyon

前面的路还长着，还要继续努力！