AcWing 1174. 受欢迎的牛
#include <iostream>
#include <cstring>
const int N = 1e4 + 10, M = 5 * 1e4 + 10;
int dfn[N], low[N], timestamp;
bool is_instk[N];
int h[N], ne[M], e[M], idx;
int stk[N], top;
int scc_cnt, id[N], scc_size[N];
int dout[N];
int n, m;
using namespace std;
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void tarjan(int u)
{
dfn[u] = low[u] = ++ timestamp ;
stk[++ top] = u;
is_instk[u] = true;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (!dfn[j])
{
tarjan(j);
low[u] = min(low[u], low[j]);
}
else if (is_instk[j])//j遍历过了且j在栈里，保证j和u在同一连通量中，简单来说是判断当前边i是不是横叉边的
{
low[u] = min(low[u], dfn[j]);
}
}
if (dfn[u] == low[u])
{
int y;
scc_cnt ++;
do{
y = stk[top --];
is_instk[y] = false;
id[y] = scc_cnt;
scc_size[scc_cnt] ++ ;
}while(y != u);
}
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
while (m --)
{
int a, b;
cin >> a >> b;
add(a, b);
}
for (int i = 1; i <= n; i ++ )
{
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= n; i ++ )
{
for (int j = h[i]; ~j; j = ne[j])
{
int k = e[j];
int a = id[i], b = id[k];
if (a != b) dout[a] ++;
}
}
int zeros = 0;
int sum = 0;
for (int i = 1; i <= scc_cnt; i ++)//遍历各个连通分量，如果一个连通分量出度为0，说明这个连通块内的牛不崇拜任何别的牛
{
//并且这个图是连通的（否则的话无解），如果有两个连通块出度都是0，那么就没有任何一头牛是最受欢迎的
if (dout[i] == 0)
{
zeros++;
sum = scc_size[i];
if (zeros == 2)
{
sum = 0;
break;
}
}
}
cout << sum;
return 0;
}
AcWing 367. 学校网络
这题最难想的是求出来连通分量后怎么处理，为什么最少需要将一个新软件直接提供给多少个学校，才能使软件能够通过网络被传送到所有学校的答案是入度为0的连通分量数
为什么最少需要添加几条新的支援关系，使得将一个新软件提供给任何一个学校，其他所有学校就都可以通过网络获得该软件？的答案是统计该图中连通块出度入度的最大值
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, M = N * N;
int dfn[N], low[N], timestamp;
int scc_cnt;
int din[N], dout[N], id[N];
int h[N], ne[M], e[M], idx;
int stk[N], top;
bool in_stk[N];
int n;
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void tarjan(int u)
{
dfn[u] = low[u] = ++ timestamp;
stk[++ top] = u;
in_stk[u] = true;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (!dfn[j])
{
tarjan(j);
low[u] = min(low[u], low[j]);
}
else if(in_stk[j] == true) low[u] = min(low[u], dfn[j]);
}
if (dfn[u] == low[u])
{
int y;
scc_cnt ++ ;
do{
y = stk[top --];
in_stk[y] = false;
id[y] = scc_cnt;
}while(y != u);
}
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i ++)
{
int j;
while (cin >> j, j)
{
add(i, j);
}
}
for (int i = 1; i <= n; i ++ ) if(!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i ++ )//遍历每个点
{
for (int j = h[i]; ~j; j = ne[j])//遍历i的邻边
{
int k = e[j];
int a = id[i], b = id[k];
if (a != b)
{
din[b] ++;
dout[a] ++ ;
}
}
}
int p, q;
for (int i = 1; i <= scc_cnt; i ++ )
{
if (din[i] == 0) p ++;
if (dout[i] == 0) q ++;
}
cout << p << endl;
if (scc_cnt == 1) puts("0");
else cout << max(p, q);
return 0;
}
AcWing 1175. 最大半连通子图
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_set>
using namespace std;
typedef long long LL;
const int N = 100010, M = 2000010;
int n, m, mod;
int h[N], hs[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int f[N], g[N];
// 有新图所以传h
void add(int h[],int a,int b)
{
e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
void tarjan(int u)
{
dfn[u] = low[u] = ++timestamp;
stk[++top] = u,in_stk[u] = true;
for(int i =h[u];~i;i=ne[i])
{
int j = e[i];
// 树枝边
if(!dfn[j])
{
tarjan(j);
low[u] = min(low[u],low[j]);
}
// 横向边
else if(in_stk[j])low[u] = min(low[u],dfn[j]);
}
// 当前分量最高点 把当前点取出来作为一个强连通分量
// ⭐
// 解释一下为什么tarjan完是逆dfs序
// 假设这里是最高的根节点fa
// 上面几行中 fa的儿子节点j都已经在它们的递归中走完了下面9行代码
// 其中就包括 ++scc_cnt
// 即递归回溯到高层节点的时候 子节点的scc都求完了
// 节点越高 scc_id越大
// 在我们后面想求链路dp的时候又得从更高层往下
// 所以得for(int i=scc_cnt(根节点所在的scc);i;i--)开始
if(dfn[u]==low[u])
{
++scc_cnt;
int y;
do{
//由于是dfs搜到一层stk.push 所以stk最先pop出来的是最深层的
y=stk[top--];
in_stk[y] = false;
// id[y] = scc_cnt 属于第scc_cnt个强连通分量
id[y] = scc_cnt;
scc_size[scc_cnt]++;
}while(y!=u);
}
}
int main()
{
memset(h,-1,sizeof h);
memset(hs,-1,sizeof hs);
cin >> n >> m >> mod;
while(m--)
{
int a,b;
cin >> a >> b;
add(h,a,b);
}
// tarjan算强连通分量
for(int i = 1;i<=n;i++)
{
if(!dfn[i])
{
tarjan(i);
}
}
unordered_set<LL> S;// 边是(u,v) hash后 u*1000000+v
for(int i=1;i<=n;i++)
{
for(int j = h[i];~j;j=ne[j])
{
int k = e[j];
int a = id[i],b= id[k];
// 边判重
LL hash = a*1000000ll+b;
// 如果a和b不在一个强连通分量 且 边(a,b)没被加过
if(a!=b && !S.count(hash))
{
add(hs,a,b);
S.insert(hash);
}
}
}
// 强连通分量算完后
// 拓扑序一定是按照节点编号递减的顺序->不需要重新拓扑排序了
// 在这个拓扑序上求最长路
for(int i=scc_cnt;i;i--)
{
// !f[i] i没被更新过 i为一条链的起点
if(!f[i])
{
f[i] = scc_size[i];
g[i] = 1;
}
for(int j = hs[i];~j;j=ne[j])
{
int k = e[j];
if(f[k]<f[i]+scc_size[k])
{
f[k] = f[i]+scc_size[k];
g[k] = g[i];
}
else if(f[k]==f[i]+scc_size[k])
{
g[k] = (g[k]+g[i])%mod;
}
}
}
int maxf = 0,sum = 0;
// 对比每一条路终点
for(int i = 1;i<=scc_cnt;i++)
{
if(f[i]>maxf)
{
maxf = f[i];
sum = g[i];
}
else if(f[i] == maxf)sum=(sum+g[i])%mod;
}
cout << maxf << endl;
cout << sum;
return 0;
}
AcWing 368. 银河
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 100010, M = 600010;
int n, m;
int h[N], hs[N], e[M], ne[M], w[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int dist[N];
void add(int h[],int a,int b,int c)
{
e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
void tarjan(int u)
{
dfn[u] = low[u] = timestamp++;
stk[++top] = u,in_stk[u] = true;//stk[++top]要和stk[top--]配 而不是stk[top++] stk[0++] = u stk[1++] = t
for(int i = h[u];~i;i=ne[i])
{
int j = e[i];
if(!dfn[j])
{
tarjan(j);
low[u] = min(low[u],low[j]);
}
else if(in_stk[j]) low[u] = min(low[u],dfn[j]);
}
if(dfn[u]==low[u])
{
scc_cnt++;
int y;
do
{
y = stk[top--];//忘了强连通分量都是通过dfs后在一个栈里的
in_stk[y] = false;//漏了
id[y] = scc_cnt;
scc_size[scc_cnt]++;
}while(y!=u);//漏了
}
}
int main()
{
cin >> n >> m;
memset(h,-1,sizeof h);
memset(hs,-1,sizeof h);
// 超级源点 和i有一个1的边
for(int i = 1;i<=n;i++)add(h,0,i,1);
while(m--)
{
int t,a,b;
cin >> t >> a >> b;
if(t==1)add(h,b,a,0),add(h,a,b,0);
else if(t==2)add(h,a,b,1);
else if(t==3)add(h,b,a,0);
else if(t==4)add(h,b,a,1);
else add(h,a,b,0);
}
tarjan(0);
bool success = true;
for(int i=0;i<=n;i++)
{
for(int j = h[i];~j;j=ne[j])
{
int k = e[j];
int a = id[i],b = id[k];
// 如果a和b在一个scc里,判断w[a][b]是否>0,
if(a==b)
{
if(w[j]>0)//ab在同一个连通块内并且有一条边为正，那么就行成了一个正环，会一直走这条路更新
{
success = false;
break;
}
}
// 如果不在一个scc里 在新图里加一条边
else add(hs,a,b,w[j]);
}
if(!success) break;
}
if(!success) cout << "-1";
else
{
// 有解 求最长路
for(int i = scc_cnt;i;i--)
{
for(int j = hs[i];~j;j=ne[j])
{
int k = e[j];
dist[k] = max(dist[k],dist[i]+w[j]);
}
}
LL res = 0;
// 结果 = 新图里每个scc的距离 * scc里的点数 = dist[scc] * cnt[scc]
for(int i=1;i<=scc_cnt;i++) res+=(LL)dist[i]*scc_size[i];
cout << res;
}
return 0;
}