题解：洛谷 P2341 受欢迎的牛

【题目来源】

洛谷：P2341 [USACO03FALL / HAOI2006] 受欢迎的牛 G - 洛谷

【题目描述】

每头奶牛都梦想成为牛棚里的明星。被所有奶牛喜欢的奶牛就是一头明星奶牛。所有奶牛都是自恋狂，每头奶牛总是喜欢自己的。奶牛之间的“喜欢”是可以传递的——如果 \(A\) 喜欢 \(B\)，\(B\) 喜欢 \(C\)，那么 \(A\) 也喜欢 \(C\)。牛栏里共有 \(N\) 头奶牛，给定一些奶牛之间的爱慕关系，请你算出有多少头奶牛可以当明星。

【输入】

第一行：两个用空格分开的整数：\(N\) 和 \(M\)。

接下来 \(M\) 行：每行两个用空格分开的整数：\(A\) 和 \(B\)，表示 \(A\) 喜欢 \(B\)。

【输出】

一行单独一个整数，表示明星奶牛的数量。

【输入样例】

3 3
1 2
2 1
2 3

【输出样例】

1

【核心思想】

  1. 问题分析：给定 \(N\) 头奶牛和 \(M\) 条有向的"喜欢"关系，"喜欢"具有传递性。明星奶牛需要被所有奶牛喜欢（包括自己）。求明星奶牛的数量。这是一个强连通分量（SCC）+ 缩点问题，关键在于发现：缩点后的 DAG 中，只有出度为 \(0\) 的 SCC 中的奶牛才可能被所有奶牛喜欢；若存在多个出度为 \(0\) 的 SCC，则没有明星奶牛。

  2. 算法选择：

    • Tarjan 算法：求所有强连通分量，将互相可达的奶牛压缩为同一个 SCC
    • 缩点建 DAG：将每个 SCC 视为一个节点，统计每个 SCC 的出度
    • 出度为 \(0\) 的 SCC：DAG 中出度为 \(0\) 的节点是"汇点"，所有其他节点都能到达它（若 DAG 连通），因此汇点 SCC 中的所有奶牛都被所有奶牛喜欢

  3. 关键步骤：

    • 读取输入：\(N, M\) 和 \(M\) 条有向边 \((A, B)\) 表示 \(A\) 喜欢 \(B\)
    • Tarjan 求 SCC：
      • \(dfn[x]\)：DFS 序时间戳
      • \(low[x]\)：通过回边能到达的最小 \(dfn\)
      • 栈维护当前 DFS 路径，\(dfn[x] = low[x]\) 时弹出栈顶至 \(x\) 形成 SCC
    • 统计 SCC 大小：\(siz[cnt]\) 记录第 \(cnt\) 个 SCC 的节点数
    • 缩点统计出度：遍历所有边，若边的两端属于不同 SCC，则源 SCC 的出度 \(dout\) 加 \(1\)
    • 判断答案：
      • 统计出度为 \(0\) 的 SCC 数量 \(zeros\)
      • 若 \(zeros = 1\)：输出该 SCC 的大小 \(siz[i]\)
      • 若 \(zeros > 1\)：输出 \(0\)（多个汇点互不可达，没有奶牛能被所有奶牛喜欢）

  4. 时间/空间复杂度：

    • 时间复杂度：\(O(N + M)\)，Tarjan 算法线性时间
    • 空间复杂度：\(O(N + M)\)，邻接表、栈及辅助数组

  5. 强连通分量缩点的核心思想：

    • 传递闭包的压缩：SCC 内部所有节点互相可达，"喜欢"关系在 SCC 内完全传递，可将 SCC 视为一个超级节点
    • DAG 的汇点性质：缩点后的 DAG 中，出度为 \(0\) 的节点是所有路径的终点，意味着所有其他 SCC 都能到达它（在连通前提下）
    • 唯一汇点判定：若 DAG 有多个汇点，则这些汇点之间不可达，没有任何一个 SCC 能被所有 SCC 到达，故明星数为 \(0\)
    • 适用于"有向图传递闭包 + 全局可达性"类问题，核心是 SCC 缩点后将复杂可达性分析转化为 DAG 的拓扑性质

【算法标签】

普及+ #强连通分量

【代码详解】

#include <bits/stdc++.h>
using namespace std;

const int N = 10005;        // 最大节点数

int n, m, a, b;            // n:节点数, m:边数, a,b:临时边变量
vector<int> e[N];          // 邻接表存储图

int dfn[N];                // DFS序（时间戳）
int low[N];                // 通过回边能到达的最小DFN值
int tot;                   // 时间戳计数器

int stk[N];                // Tarjan算法栈
int instk[N];              // 标记节点是否在栈中
int top;                   // 栈顶指针

int scc[N];                // 存储每个节点所属的强连通分量编号
int siz[N];                // 存储每个强连通分量的大小（节点数）
int cnt;                   // 强连通分量计数器

int dout[N];               // 每个强连通分量的出度

/**
 * Tarjan算法求强连通分量
 * @param x 当前节点
 */
void tarjan(int x)
{
    // 初始化当前节点的DFN和LOW值
    dfn[x] = low[x] = ++tot;

    // 将当前节点压入栈并标记
    stk[++top] = x;
    instk[x] = 1;

    // 遍历当前节点的所有邻接节点
    for (int y : e[x])
    {
        // 如果邻接节点y未被访问
        if (!dfn[y])
        {
            tarjan(y);                      // 递归访问y
            low[x] = min(low[x], low[y]);   // 更新low值
        }
        // 如果y已被访问且在栈中（回边）
        else if (instk[y])
        {
            low[x] = min(low[x], dfn[y]);   // 通过回边更新low值
        }
    }

    // 如果当前节点是强连通分量的根
    if (dfn[x] == low[x])
    {
        int y;
        ++cnt;  // 增加强连通分量计数

        // 弹出栈中节点直到遇到当前节点
        do
        {
            y = stk[top--];     // 弹出栈顶节点
            instk[y] = 0;       // 标记节点已出栈
            scc[y] = cnt;       // 记录节点所属的强连通分量
            ++siz[cnt];         // 增加当前强连通分量的大小
        }
        while (y != x);         // 直到弹出当前节点
    }
}

int main()
{
    // 输入节点数和边数
    cin >> n >> m;

    // 输入所有边
    while (m--)
    {
        cin >> a >> b;
        e[a].push_back(b);  // 添加有向边a->b
    }

    // 对每个未访问的节点执行Tarjan算法
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
        {
            tarjan(i);
        }
    }

    // 构建强连通分量之间的有向无环图（DAG）
    for (int x = 1; x <= n; x++)
    {
        for (int y : e[x])
        {
            // 如果x和y不在同一个强连通分量中
            if (scc[x] != scc[y])
            {
                ++dout[scc[x]];  // 源分量的出度增加
            }
        }
    }

    // 统计出度为0的强连通分量
    int sum = 0;    // 存储最终结果
    int zeros = 0;   // 出度为0的强连通分量数量

    for (int i = 1; i <= cnt; i++)
    {
        // 如果当前强连通分量出度为0
        if (dout[i] == 0)
        {
            sum = siz[i];  // 记录该分量的大小
            ++zeros;       // 增加出度为0的分量计数
        }
    }

    // 如果有多个出度为0的强连通分量，则结果为0
    if (zeros > 1)
    {
        sum = 0;
    }

    // 输出结果
    cout << sum << endl;

    return 0;
}

【运行结果】

3 3
1 2
2 1
2 3
1
posted @ 2026-08-28 15:54  团爸讲算法  阅读(4)  评论(0)    收藏  举报