1，定义
强连通：两个点u，v可以互相到达
强连通分量，一个图中每一块的任意点可以互相到达的数量（不一定整个图强连通，但是局部强连通）
2，tarjan算法
思路：
1，寻找一个强连通分量：说直白点，寻找一个“环”，我们在用dfs遍历图的时候，可以把走过的点存起来，一旦成功找到一个环，我们把这个环的点标记然后逐一从存入的数组弹出（因为dfs深度遍历的原因，我们保证一旦找到一个环，dfs上的点连续一段都是这个环的点），显然后找到的点先弹出——任意联想到栈（我们可以手打一个栈数组）
2，dfs深度遍历当然需要一个dfn数组记录深度，还需要一个数组来表示其是否是环low数组，我们可以起初让dfn=low,当我们深度遍历环上最后一个点u时（假设这个点还没有访问过），毫无疑问，这个点下一个指向环的第一个点v（深度较低的点），我们可以low[u]=min(low[u],dfn[v]),即low[u]等于dfn[v]的深度，记录该深度有一个环，后面回去时，把环上的点的low都改为low[u](因为深度不断变深，环上点的low肯定小于第一个点的深度dfn[v]==low[v]==low[u](最后一个点更新后）
如图：
核心代码就是
void tarjan(int u)
{
dfn[u] = low[u] = ++dfncnt;//起初让dfn=low
insta[u] = 1;//insta记录栈中存在这个数
sta[++top] = u;//记录栈顶为u
for (int i = head[u]; i; i = edge[i].next)//遍历子代
{
int v = edge[i].to;
if (!dfn[v])//如果子代没有访问过，深入
{
tarjan(v);
low[u] = min(low[u], low[v]);//回来时，如果有形成环，就会更新low[u],没有的话，low[u]深度一定小于子代的
}
else if (insta[v])low[u] = min(low[u], dfn[v]);//如果子代遍历过，询问是否在栈内，是，那就说明形成一个环，记录环上第一个点的深度，说明深度low[u]=dfn[v]存在一个环
}
if (dfn[u] == low[u])//回来时，如果low仍然等于dfn，说明u是环起点（自己跟自己也算一个环
{
++cnt;//记录强连通分量增加
while (1)
{
int v = sta[top--];//不断退栈，top指针指向栈顶，减少就是退栈
insta[v] = 0;//标记已经退栈
scc[v] = cnt;//scc记录点v属于第几个强连通分量cnt
if (u == v)break;//当退完u这个起点，退出退栈操作
}
}
}
3，练习题1：HDU - 3639 Hawk-and-Chicken
思路：缩点+反向入度
1，首先，如果有一群人（x人）形成一个环的互相赞赏，毫无疑问，他们给别人投票，那个人一次加x票，有人给他们其中一个人投票，环里面每个人都会加一票，所以，这个环看成一个点（缩点）
2，缩点后，你会发现，更新的图，箭头最终指向的那些点（就是被别人指向，自己不指向别人的点，才有可能为胜者们，毫无疑问存在这样的点，因为不存在，实际应该属于一个环（矛盾）），这时候可能思考单向箭头那么就拓扑排序，但是这样太费时间。
我们可以将箭头反向，他们就成为唯一不被别人指向的点，那么我们走完tarjan重新建反向图时，用in数组标记是否有被指向，最后dfs求取没有被指向的点的值即可
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef unsigned long long ull;
typedef pair<long long, long long> pll;
const int INF = 0x3f3f3f3f; //int型的INF
const ll llINF = 0x3f3f3f3f3f3f3f3f;//ll型的llINF
const int N = 5e3 + 10;
int sta[N], scc[N], dfn[N], low[N], head[N], hd[N], sum[N], sz[N];
bool insta[N], in[N], vis[N];
int num, cnt, dfncnt, top, num1;
struct node
{
int to, next;
} edge[30005], eg[30005];
void init()
{
memset(head, 0, sizeof(head));
memset(hd, 0, sizeof(hd));
memset(dfn, 0, sizeof(dfn));
memset(in, 0, sizeof(in));
memset(sum, 0, sizeof(sum));//
num = num1 = top = dfncnt = cnt = 0;
}
void add(int u, int v)//正向建图
{
edge[++num].next = head[u];
edge[num].to = v;
head[u] = num;
}
void add1(int u, int v)//反向建图
{
eg[++num1].next = hd[u];
eg[num1].to = v;
hd[u] = num1;
}
void tarjan(int u)
{
dfn[u] = low[u] = ++dfncnt;
insta[u] = 1;
sta[++top] = u;
for (int i = head[u]; i; i = edge[i].next)
{
int v = edge[i].to;
if (!dfn[v])
{
tarjan(v);
low[u] = min(low[u], low[v]);
}
else if (insta[v])low[u] = min(dfn[v], low[u]);
}
if (dfn[u] == low[u])
{
++cnt;
sz[cnt] = 0;//sz数组存储每个环内点的数量，一个环（x人）给人的票一次就是x，自己内部赞赏是x-1
while (1)
{
int v = sta[top--];
insta[v] = 0;
scc[v] = cnt;
++sz[cnt];
if (u == v)break;
}
}
}
int dfs(int u)//求指向u的票，只需要u自己内部赞同票加上他指向的点所获得的票
{
vis[u] = 1;
int ans = sz[u];
for (int i = hd[u]; i; i = eg[i].next)
{
int v = eg[i].to;
if (!vis[v])ans += dfs(v);
}
return ans;
}
int main()
{
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t, t1 = 0, n, m, x, y;
cin >> t;
while (t--)
{
++t1;
init();
cin >> n >> m;
for (int i = 1; i <= m; ++i)cin >> x >> y, add(x, y);
for (int i = 0; i < n; ++i)if (!dfn[i])tarjan(i);
for (int i = 0; i < n; ++i)
{
int u = scc[i];
for (int j = head[i]; j; j = edge[j].next)
{
int v = scc[edge[j].to];
if (u != v)add1(v, u), in[u] = 1;//反向建环的图
}
}
int ans = -1;
for (int i = 1; i <= cnt; ++i)
{
if (!in[i]) memset(vis, 0, sizeof(vis)), sum[i] = dfs(i) - 1, ans = max(ans, sum[i]);//没有被指向的，每次重置标记，求其值，最后sum-1，就是因为环内部认同是x-1
}
cout << "Case " << t1 << ": " << ans << endl;
bool flag = 1;
for (int i = 0; i < n; ++i)
{
if (sum[scc[i]] == ans)
{
if (flag)flag = 0, cout << i;
else cout << ' ' << i;
}
}
cout << endl;
}
return 0;
}4，练习题2：The King’s Problem
思路：缩点+最小覆盖路径
满足可以是同一个州的条件：
1，如果u，v两点可以互相到达——必须一个州——显然，互相到达的环缩点为一个就好
2，如果u，v之间存在一条路径（不一定要能相互到达，可以单向，但是要求经过的城市都是这个州的），那么可以是一个州——我们缩点后，只剩下单向箭头，我们期望把他们分成尽可能少的部分，也就是尽可能多的点可以和一起（实际就是最小覆盖路径问题）
一个结论：最小路径覆盖==图上点总数--最大匹配数
最大匹配数的求法与二分图的匈牙利算法一样（我们把所有原点左右边都放一边）
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef unsigned long long ull;
typedef pair<long long, long long> pll;
const int INF = 0x3f3f3f3f; //int型的INF
const ll llINF = 0x3f3f3f3f3f3f3f3f;//ll型的llINF
const int N = 5e3 + 10;
int sta[N], head[N], hd[N], dfn[N], low[N], scc[N], match[N];
bool insta[N], vis[N];
int num, num1, top, dfncnt, cnt;
struct node
{
int to, next;
} edge[N * 20 ], eg[N * 20 ];
void init()
{
memset(dfn, 0, sizeof(dfn));
memset(head, 0, sizeof(head));
memset(hd, 0, sizeof(hd));
memset(match, 0, sizeof(match));
memset(vis, 0, sizeof(vis));
num = num1 = top = cnt = dfncnt = 0;
}
void add(int u, int v)
{
edge[++num].next = head[u];
edge[num].to = v;
head[u] = num;
}
void add1(int u, int v)
{
eg[++num1].next = hd[u];
eg[num1].to = v;
hd[u] = num1;
}
void tarjan(int u)
{
dfn[u] = low[u] = ++dfncnt;
insta[u] = 1;
sta[++top] = u;
for (int i = head[u]; i; i = edge[i].next)
{
int v = edge[i].to;
if (!dfn[v])
{
tarjan(v);
low[u] = min(low[u], low[v]);
}
else if (insta[v])low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u])
{
++cnt;
while (1)
{
int v = sta[top--];
insta[v] = 0;
scc[v] = cnt;
if (u == v)break;
}
}
}
int tfind(int u)//寻找u是否可以连出线，有返回1，匹配数+1
{
for (int i = hd[u]; i; i = eg[i].next )
{
int v = eg[i].to;
if (!vis[v])//v点是否被匹配过
{
vis[v] = 1;//更改vis写在里面，被匹配是右边的事，放外面会误标记左边找匹配的点
if (!match[v] || tfind(match[v]))//没有被匹配，或者原来匹配值回去可以找到其他匹配点（就会返回1），或者写法，是判断有无被匹配在前，有才访问||后面的内容
{
match[v] = u;
return 1;
}
}
}
return 0;
}
int main()
{
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t, n, m, x, y;
cin >> t;
while (t--)
{
init();
cin >> n >> m;
for (int i = 1; i <= m; ++i)cin >> x >> y, add(x, y);
for (int i = 1; i <= n; ++i)if (!dfn[i])tarjan(i);
for (int i = 1; i <= n; ++i)//缩点重新建图
{
int u = scc[i];
for (int j = head[i]; j; j = edge[j].next)
{
int v = scc[edge[j].to];
if (u != v)add1(u, v);
}
}
//cout << cnt;
int ans = 0;
for (int i = 1; i <= cnt; ++i)ans += tfind(i);
cout << cnt - ans << endl;
}
return 0;
}
1037
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
