hdu1827&&hdu2767----Kosaraju算法

/**
*  hdu1827
*  题意：给一个有向图，每个顶点有个权值，求入度为0的顶点的个数及从入度为0的顶点出发，
*  到达图的所有顶点的最小花费和
*  解法：缩点后，从入度为0的顶点在反向图中dfs一遍，求出路径上的顶点的最小花费
**/

#include <cstdio>
#include <cstring>
#include <climits>
#include <iostream>

using namespace std;

int scc[1005];  ///缩图，存强连通块
int dfn[1005];  ///存顶点访问顺序
int scc_root[1005]; ///存强连通分量中的某一个顶点
int ind[1005];  ///缩图，存入度数
bool vis[1005]; ///访问标记
int cost[1005]; ///花费
int sc, cnt, mincc;
int minp, minc;
///sc    对同一个强连通子图中的顶点标记为同一标志
///cnt   -----
///total 把每个强连通子图看成是一个点，统计其他点可到该点的数目
struct Node {
int u;
Node *next;
Node() {}
Node(int uu, Node *p=NULL) : u(uu), next(p){}
};
struct Graph {
Node *head;
Graph() {}
}G[1005], NG[1005];
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) {///建图
Node *p = new Node(u);
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);
}
}
}
void dfs_three(int k) {///第三次dfs
vis[k] = true;
if (mincc > cost[k]) {///访问路径上的最小花费
mincc = cost[k];
}
for (Node *p=NG[k].head; p!=NULL; p=p->next) {
if (!vis[p->u])  {
dfs_three(p->u);
}
}
}
void 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;
scc_root[sc] = dfn[i];
dfs_two(dfn[i]);
}
}

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]) {///不在同一个强连通内
++ind[scc[p->u]];
}
}
}

minc = 0;
minp = 0;
for (int i=1; i<=sc; ++i) {
if (ind[i] == 0) {///对入度为0的点进行第三次dfs
++minp;
mincc = INT_MAX;
memset(vis, false, sizeof(vis));
dfs_three(scc_root[i]);
minc += mincc;
///           minc += cost[scc_root[i]];
}
}
}
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 v, u;
for (int i=1; i<=n; ++i) {
scanf("%d", &cost[i]);
}
while (m--) {
scanf("%d%d", &v, &u);
buildG(G, v, u);
buildG(NG, u, v);
}
kosaraju(n);
deleteG(G, n);
deleteG(NG, n);

printf("%d %d\n", minp, minc);
}
return 0;
}

/**
* hdu2767
* 题意: 在一个有向图中，问至少加几条边让整个图变成强连通
* 解法：缩点后统计出度为0和入度为0的点的个数，两者取最大值
**/
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

int dfn[20005];  ///存顶点访问顺序
int scc[20005];  ///缩图，存强连通块
int ind[20005];  ///缩图，存入度数
int oud[20005];  ///缩图，存出度数
bool vis[20005]; ///访问标记
int cnt, sc;
struct Node {
int u;
Node *next;
Node() {}
Node(int uu, Node *p=NULL) : u(uu), next(p){}
};
struct Graph {
Node *head;
Graph() {}
}G[20005], NG[20005];
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) {///建图
Node *p = new Node(u);
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) {
ind[i] = oud[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]) {///不在同一个强连通内
++oud[scc[i]];
++ind[scc[p->u]];
}
}
}
int max1 = 0;
int max2 = 0;
for (int i=1; i<=sc; ++i) {
if (ind[i] == 0) ++max1;
if (oud[i] == 0) ++max2;
}

int ans = max(max1, max2);
if (sc == 1) ans = 0;
return ans;
}
void deleteG(Graph g[], int n) {///释放图
for (int i=1; i<=n; ++i) {
Node *p = g[i].head;
if (p != NULL) {
Node *pt = p->next;
while (p != NULL) {
delete p;
if (pt == NULL) {
p = NULL;
break;
}else {
p = pt;
pt = pt->next;
}
}
g[i].head = NULL;
}
}
}
int main(void) {
int t, n, m;

scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
initG(n);
while (m--) {
int u, v;
scanf("%d%d", &v, &u);
buildG(G, v, u);
buildG(NG, u, v);
}

int ans = kosaraju(n);
printf("%d\n", ans);

deleteG(G, n);
deleteG(NG, n);
}

return 0;
}