Union - Find 、 Adjacency list 、 Topological sorting Template

Find Function Optimization:

After Path compression：

int find(int x){

    return root[x] == x ? x : (root[x] = find(root[x]));

}

Avoid Stack overflow:

int find(int a){

    while(root[a]!=a){

        a=root[a];

    }

    return a;

}

 Combined with rank : (Combined with the height of tree)

int rank[MAXSIZE];



void UNION(int x, int y) {

    int f1 = find(x);

    int f2 = find(y);

    if (rank[f1] <= rank[f2]) {

        root[f1] = f2;

        if (rank[f1] == rank[f2]) {

            rank[f2] ++;    

        }   

    } 

    else    root[f2] = f1;

}

　　

---

Union Function :

void Union(int a,int b){

    int ra = find(a);

    int rb = find(b);

    root[rb]=ra; // ra is the father of rb

}

---

 Species Union - Find Function:

 

int find(int i){

    if(root[i]==i)return i;

    int ans=root[i];

    root[i]=find(root[i]);

    dis[i]+=dis[ans];//求出节点a到根的距离

    return root[i];

}

void Union(int u,int v,int root_u,int root_v,int x){

    root[root_v]=root_u;

    dis[root_v]=dis[u]+x-dis[v];//使用的是数学中向量计算

}

 

 while(m--){

            scanf("%d%d%d",&u,&v,&dist);

            int x=find(u),y=find(v);

            if(x!=y)

                Union(u,v,x,y,dist);

            else

                if(dis[u]+dist!=dis[v])

                    ans++;

        }

---

 

Operation of Adjacency list :

int head[MAXSIZE];

struct node{

    int cur,pre,weight;

}edge[MAXSIZE];

int cnt;//The num of Edges



void initEdge(){

    cnt = 0;

    for(int i = 0; i< MAXSIZE; i++)

        head[i] = -1;

}



void addEdge(int from , int cur){

    edge[cnt].cur = cur;

    edge[cnt].pre = head[from];

    head[from] = cnt++;

}



void print(int v){

    for(int i = head[v]; i != -1; i = edge[i].pre){

        int cur = edge[i].cur;

        printf("%d ",cur);

    }

}

---

 Topological sorting：

//按如下建图，A在B前，则建一条A->B的有向边

//按如下策略排序：

//图中每次删除入度为0的节点，删除的节点加入已排序序列末尾

int sortlist[1000];

int topsort(){

    queue<int>q;

    int idx = 0;

    for(int i = 0; i < n; i++)//n为要排序的节点个数

        if(indgree[i] == 0)

            q.push(i);

    while(!q.empty()){

        int cur = q.front;

        sortlist[idx++] = cur;

        q.pop();

        n--;

        for(int i = 0; i< l[cur].size(); i++){//l[cur][i]表示以cur为起点i为终点的有向边

            indgree[l[cur][i]]--;

            if(!indgree[l[cur][i]])

                q.push(l[cur][i]);

        }

    }

    if(n > 0)   return 0;//当n>0时，说明有节点未排序则表示节点关系有冲突

    else    return 1;

}

 邻接矩阵：

int indgree[MAXN], map[MAXN][MAXN];

int n;

stack <int> ss;

bool topsort(){

    int i, j;

    while(1){

        for(i = 1; i <= n; ++i)

            if(indgree[i] == 0)  break;

        if(i != n + 1){

            for(j = 1; j <= n; ++j)

                if(map[i][j] == 1){

                    map[i][j] = 0;

                    --indgree[j];

                }

            indgree[i] = -1;

            ss.push(i);

        }

        else    break;

    }

    bool flag = true;

    for(i = 1; i <= n; ++i){

        for(j = 1; j <= n; ++j){

            if(map[i][j] == 1){

                flag = false;

            }

        }

    }

    return flag;

}



void print(){

    while(!ss.empty()){

        printf("%d ",ss.top());

        ss.pop();

    }

    printf("\n");

}