图论练习

https://www.luogu.org/problemnew/show/P2661

把同学看作点，传信息看作连一条边，那么游戏结束当且仅当图中存在环，这题中即是求最小环。

DFS当然是可以的，出于偷懒这里用了带权并查集，在路径压缩和合并时还需要更新父节点的值。

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

const int maxn = 2e5+5;
int n;
int fa[maxn], dis[maxn], minlen;

int find(int x)
{
    if (x != fa[x])
    {
        int father = fa[x];
        fa[x] = find(fa[x]);
        dis[x] += dis[father];
    }
    return fa[x];
}

inline void unite(int x, int y)
{
    int fx = find(x), fy = find(y);
    if (fx != fy)
    {
        fa[fx] = fy;
        dis[x] = dis[y]+1;
    }else minlen = min(minlen, dis[x]+dis[y]+1);
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i) fa[i] = i;
    minlen = 0x3f3f3f3f;
    int tmp;
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &tmp);
        unite(i, tmp);
    }
    printf("%d\n", minlen);
}

---

https://www.luogu.org/problemnew/show/P1330

题目要求每条边至少要选一个点，又说不能两个点都选中，那当然就是说：每条边都只能选一个点了。

这样问题转化为染色问题了，但是染色问题的前提是连通图，而题目没有保证连通……那对每个点都遍历一次，不就分成了几个子连通图嘛？最后每个子连通图的答案之和就是最终答案。

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

const int maxn = 10005;
bool vis[maxn];
int n, m, u, v, ans1, ans2, ans;
int color[maxn];
vector<int> g[maxn];

void dfs(int now, int c)
{
    if (color[now])
    {
        if (color[now] != c) {puts("Impossible"); exit(0);}
        else return;
    }
    vis[now] = true;
    color[now] = c;
    c == 1 ? ++ans1 : ++ans2;
    for (int i = 0; i < g[now].size(); ++i)
        dfs(g[now][i], (c&1)+1);
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; ++i)
    {
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for (int i = 1; i <= n; ++i)
        if (!vis[i] && g[i].size())
        {
            ans1 = ans2 = 0;
            dfs(i, 1);
            ans += min(ans1, ans2);
        }
    printf("%d\n", ans);
}

---

https://www.luogu.org/problemnew/show/P1341

题目疯狂暗示欧拉路径（奇点数为0）/回路（奇点数为2）……一对字母间连无向边，然后预处理出无解的情况（奇点数既不为0又不为2）和作为起点的点（注意由于要字典序最小，所以{欧拉路径：第一个在连通图内的点；欧拉回路：第一个奇点}）。

之后Hierholzer算法跑dfs删边，本来结果是要push进栈里的，但这里可以直接扔进字符串里反序输出。

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

const int maxn = 300;
bool g[maxn][maxn];
int degree[maxn];
string s, ans;
int n;

void dfs(int now)
{
    for (int i = 0; i < maxn; ++i)
        if (g[now][i])
        {
            g[now][i] = g[i][now] = false;
            dfs(i);
        }
    ans += now;
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; ++i)
    {
        cin >> s;
        g[s[0]][s[1]] = g[s[1]][s[0]] = true;
        ++degree[s[0]]; ++degree[s[1]];
    }
    int cnt = 0, first = 0;
    for (int i = 0; i < maxn; ++i)
        if (degree[i]&1)
        {
            ++cnt;
            if (!first) first = i;
        }
    if (!first)
        for (int i = 0; i < maxn; ++i)
            if (degree[i]) {first = i; break;}
    if (cnt && cnt != 2) return 0*puts("No Solution");
    dfs(first);
    reverse(ans.begin(), ans.end());
    cout << ans << endl;
}

---

https://www.luogu.org/problemnew/show/P2921

对现在的我来说是难题，所以不得不看了题解……以下内容（包括代码）借鉴了题解：

建图可以得到一个基环外向树，然后网上很多解法都是tarjan缩点。。看到一个比较简洁的做法是先拓扑排序删链，然后计算环上点的答案，最后由此dfs出其它点的答案。

是的，三个递归函数……每个单独看都很简单，但就是想不到。代码挺优雅的。

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

const int maxn = 1e5+5;
int n, nxt[maxn], deg[maxn], ans[maxn];
bool vis[maxn];
#define rep(i,n) for(int i=1;i<=n;++i)

void del(int now)
{
    vis[now] = true;
    --deg[nxt[now]];
    if (!deg[nxt[now]]) del(nxt[now]);
}

int dfs(int now, int dep)
{
    ans[now] = dep;
    if (ans[nxt[now]]) return dep;
    return ans[now] = dfs(nxt[now], dep+1);
}

int solve(int now)
{
    if (ans[now]) return ans[now];
    return ans[now] = solve(nxt[now])+1;
}

int main()
{
    cin >> n;
    rep(i,n) scanf("%d", nxt+i), ++deg[nxt[i]];
    rep(i,n) if (!deg[i] && !vis[i]) del(i);
    rep(i,n) if (deg[i] && !ans[i]) dfs(i, 1);
    rep(i,n) if (!deg[i] && !ans[i]) solve(i);
    rep(i,n) printf("%d\n", ans[i]);
}

图论真是深坑啊。