hdu3072&&hdu3639----Kosaraju算法

/**
*  hdu3072
*  题意：给出有向图，每条边有权值，求出强连通分量之间的最小边权，最后边权相加
*  解析：缩图，更新不在同一个强连通分量的最小边权
**/
#include <cstdio>
#include <climits>
#include <cstring>
#include <iostream>

using namespace std;

int scc[50005];  ///缩图，存强连通块
int dfn[50005];  ///存顶点访问顺序
bool vis[50005]; ///访问标记
int ees[50005];
int sc, cnt;
///sc    对同一个强连通子图中的顶点标记为同一标志
///cnt   -----
struct Node {
    int u;
    int w;
    Node *next;
    Node() {}
    Node(int uu, int ww, Node *p=NULL) : u(uu), w(ww), next(p){}
};
struct Graph {
    Node *head;
    Graph() {}
}G[50005], NG[50005];
void initG(int n) {///初始化
    for (int i=1; i<=n; ++i) {
        G[i].head = NULL;
        NG[i].head = NULL;
    }
}
void buildG(Graph g[], int v, int u, int w) {///建图
    Node *p = new Node(u, w);
    p->next = g[v].head;
    g[v].head = p;
}
void dfs_one(int k) {///第一次dfs求顶点访问顺序
    vis[k] = true;
    for (Node *p=G[k].head; p!=NULL; p=p->next) {
        if (!vis[p->u]) {
            dfs_one(p->u);
        }
    }
    dfn[++cnt] = k;///存顶点访问顺序
}
void dfs_two(int k) {///第二次dfs缩图
    scc[k] = sc;     ///同一个强连通分量标记为一样的标志
    vis[k] = true;
    for (Node *p=NG[k].head; p!=NULL; p=p->next) {
        if (!vis[p->u]) {
            dfs_two(p->u);
        }
    }
}
int kosaraju(int n) {
    cnt = 0;
    memset(vis, false, sizeof(vis));
    for (int i=1; i<=n; ++i) {///求顶点访问顺序
        if (!vis[i]) {
            dfs_one(i);
        }
    }
    memset(vis, false, sizeof(vis));
    sc = 0;
    for (int i=n; i>0; --i) {///缩图
        if (!vis[dfn[i]]) {
            ++sc;
            dfs_two(dfn[i]);
        }
    }

    for (int i=1; i<=sc; ++i)  {
        ees[i] = INT_MAX;
    }
    for (int i=1; i<=n; ++i) {
        for (Node *p=G[i].head; p!=NULL; p=p->next) {
            if (scc[i] != scc[p->u]) {
                ees[scc[p->u]] = min(ees[scc[p->u]], p->w);///更新强连通分量之间的最小边权
            }
        }
    }
    int sum = 0;
    for (int i=1; i<=sc; ++i) {
        if (ees[i] != INT_MAX)  {///求这些最小边权和
            sum += ees[i];
        }
    }
    return sum;
}
void del(Node *pNode) {
    if (pNode != NULL) {
        del(pNode->next);
        delete pNode;
        pNode = NULL;
    }
}
void deleteG(Graph g[], int n) {///释放图
    for (int i=1; i<=n; ++i) {
        if (g[i].head != NULL) {
            del(g[i].head);
        }
    }
}

int main(void) {
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF) {
        initG(n);
        int u, v, w;
        for (int i=0; i<m; ++i) {
            scanf("%d%d%d", &v, &u, &w);
            buildG(G, v+1, u+1, w);
            buildG(NG, u+1, v+1, w);
        }

        printf("%d\n", kosaraju(n));
        deleteG(G, n);
        deleteG(NG, n);
    }
    return 0;
}



/**
*  hdu3639
*  题意：给出有向图，求出度为0的顶点，到达这些顶点的路径所经过的顶点数最多
*  解析：缩图，建立反向图，从入度为0的顶点dfs，dfs过程中，保存从该点出发，能够访问到的顶点数
**/
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

struct Node {
    int u;
    Node *next;
    Node() {}
    Node(int uu, Node *p=NULL) : u(uu), next(p){}
};
struct Graph {
    Node *head;
    Graph() {}
}G[5005], NG[5005], NNG[5005];
int scc_vs[5005];///存每个强连通子图的顶点个数
int dfn[5005];   ///顶点访问顺序
int scc[5005];   ///缩图
int ind[5005];   ///入度数
int vvs[5005];   ///缩点，反向图，存其他顶点可到该点的数目
bool vis[5005];  ///访问标记
int sc, cnt, vers, total;
///sc    统计强连通子图的个数和对同一个强连通子图中的顶点染成同一色
///cnt   ----
///vers  统计一个强连通子图的顶点个数
///total 把每个强连通子图看成是一个点，统计其他点可到该点的数目
void initG(int n) {///初始化图
    for (int i=1; i<=n; ++i) {
        G[i].head = NG[i].head = NNG[i].head = NULL;
    }
}
void buildG(Graph g[], int v, int u) {
    Node *p = new Node(u);
    p->next = g[v].head;
    g[v].head = p;
}
void dfs_one(int k) {
    vis[k] = true;
    for (Node *p=G[k].head; p!=NULL; p=p->next) {
        if (!vis[p->u])  {
            dfs_one(p->u);
        }
    }
    dfn[++cnt] = k; ///顶点k入栈
}
void dfs_two(int k) {
    scc[k] = sc;   ///标记
    vis[k] = true;
    ++vers;       ///该强连通子图的顶点数加1
    for (Node *p=NG[k].head; p!=NULL; p=p->next) {
        if (!vis[p->u])  {
            dfs_two(p->u);
        }
    }
}
void dfs_three(int k) {
    vis[k] = 1;
    total += scc_vs[k];
    for (Node *p=NNG[k].head; p!=NULL; p=p->next) {
        if (!vis[p->u])  {
            dfs_three(p->u);
        }
    }
}
int kosaraju(int n) {
    sc = 0;
    cnt = 0;
    memset(vis, false, sizeof(vis));
    for (int i=1; i<=n; ++i) {
        if (!vis[i])  {
            dfs_one(i);
        }
    }
    memset(vis, false, sizeof(vis));
    for (int i=cnt; i>0; --i) {
        if (!vis[dfn[i]]) {
            ++sc;
            vers = 0;
            dfs_two(dfn[i]);
            scc_vs[sc] = vers;
        }
    }

    for (int i=1; i<=sc; ++i) {
        ind[i] = 0;
    }
    for (int i=1; i<=n; ++i) {///缩点反向建图
        for (Node *p=G[i].head; p!=NULL; p=p->next) {
            if (scc[i] != scc[p->u]) {
                buildG(NNG, scc[p->u], scc[i]);
                ++ind[scc[i]];
            }
        }
    }
    for (int i=1; i<=sc; ++i)  {
        vvs[i] = -1;
    }
    int maxx = -1;
    for (int i=1; i<=sc; ++i) {
        if (ind[i] == 0) {///对入度为0的点进行第三次DFS
            total = 0;
            for (int j=1; j<=sc; ++j)  {
                vis[j] = false;
            }
            dfs_three(i);
            vvs[i] = total;
            maxx = max(maxx, vvs[i]);
        }
    }

    return maxx;
}
void del(Node *pNode) {
    if (pNode != NULL) {
        del(pNode->next);
        delete pNode;
        pNode = NULL;
    }
}
void deleteG(Graph g[], int n) {///释放图
    for (int i=1; i<=n; ++i) {
        if (g[i].head != NULL) {
            del(g[i].head);
        }
    }
}
int main(void) {
    int n, m, t, cas = 0;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n, &m);
        initG(n);
        int v, u;
        for (int i=0; i<m; ++i) {
            scanf("%d%d", &v, &u);
            buildG(G, v+1, u+1);
            buildG(NG, u+1, v+1);
        }
        int ans = kosaraju(n);
        printf("Case %d: %d\n", ++cas, ans - 1);
        int cs = 0;
        for (int i=1; i<=n; ++i) {
            if (vvs[scc[i]] == ans) {
                if (cs != 0)  {
                    printf(" %d", i-1);
                }else  {
                    cs = 1;
                    printf("%d", i-1);
                }
            }
        }
        deleteG(G, n);
        deleteG(NG, n);
        deleteG(NNG, sc);
        printf("\n");
    }
    return 0;
}