HDU5915

题意

给定一个$n$个点$n$条边的无向图，现在从某一点$s$出发，每个点都经过一遍，最后在$t$点停止，经过的边数为$l$

求字典序最小的三元组$(l,s,t)$

题解

对于一个基环树首先预处理出环上的点 $a[]$ 和环的长度 $Circle$

当初始点 $s$ 和终点 $t$ 在同一棵子树的时候，经过所有点所需要经过的路程为 $s$ 到 $t$ 的路径和其他的路径的两倍，总路径长度为 $2\ast n-len(s,t)-Circle$

为了使得 $(l,s,t)$ 最小，只需要枚举环上每棵子树上的字典序最小的直径即可

当初始点 $s$ 和终点 $t$ 不在同一棵子树的时候，令 $s$ 在环上的根为 $x$，$t$ 在环上的根为 $y$，总路径长度为 $2\ast n-2-(s,x)-(t,y)-(x,y)$

预处理环上所有子树，字典序最小的最深点，记长度为 $w[i]$，那么两点之间的 $(s,x)+(t,y)+(x,y)=(w[i]+i)-(w[j]-j)$

那么将环上的数组倍增，然后对于每个 $i$ 用单调队列维护前 $k-1$ 个数中的最值即可

代码

用 $tarjan$ 找环是因为好久没写过了，练一练。事实上 $dfs$ 就行了。

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

typedef pair<int, int> pii;
typedef tuple<int, int, int> tp;
const int maxn = 2e5 + 5;
class QIO {
  public:
    char buf[1 << 21], *p1 = buf, *p2 = buf;
    int getc() {
        return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
                            p1 == p2)
                   ? EOF
                   : *p1++;
    }
    int read() {
        int ret = 0, f = 0;
        char ch = getc();
        while (!isdigit(ch)) {
            if (ch == '-')
                f = 1;
            ch = getc();
        }
        while (isdigit(ch)) {
            ret = ret * 10 + ch - 48;
            ch = getc();
        }
        return f ? -ret : ret;
    }
} io;

int head[maxn], tot;
struct Edge {
    int v;
    int next;
} edge[maxn];
inline void AddEdge(int u, int v) {
    edge[++tot].v = v;
    edge[tot].next = head[u];
    head[u] = tot;
}

void init(int n) {
    tot = 0;
    fill(head + 1, head + 1 + n, 0);
}
void Read(int n) {
    int u, v;
    for (int i = 1; i <= n; i++) {
        u = io.read();
        v = io.read();
        AddEdge(u, v);
        AddEdge(v, u);
    }
}

int col[maxn], col_num, color, circle;
int a[maxn * 2], k;
namespace Tarjan {
int dfn[maxn], low[maxn], dfs_num;
int stack[maxn], top;
void dfs(int now, int fa) {
    dfn[now] = low[now] = ++dfs_num;
    stack[++top] = now;
    for (int i = head[now]; i; i = edge[i].next) {
        if (edge[i].v == fa)
            continue;
        if (!dfn[edge[i].v]) {
            dfs(edge[i].v, now);
            low[now] = min(low[now], low[edge[i].v]);
        } else
            low[now] = min(low[now], dfn[edge[i].v]);
    }
    if (dfn[now] == low[now]) {
        col_num++;
        int j, cnt = 0;
        do {
            j = stack[top--];
            col[j] = col_num;
            cnt++;
        } while (j != now);
        if (cnt > 1) {
            color = col_num;
            circle = cnt;
        }
    }
}
void getCircle(int n) {
    int now;
    for (int i = 1; i <= n; i++) {
        if (col[i] == color) {
            now = i;
            break;
        }
    }

    int pre = 0, end = now;
    do {
        for (int i = head[now]; i; i = edge[i].next) {
            if (edge[i].v == pre)
                continue;
            if (col[edge[i].v] == color) {
                pre = now;
                now = edge[i].v;
                a[++k] = now;
                break;
            }
        }
    } while (now != end);
}

void Trajan(int n) {
    dfs_num = col_num = top = k = 0;
    fill(dfn + 1, dfn + 1 + n, 0);

    for (int i = 1; i <= n; i++)
        if (!dfn[i])
            dfs(i, 0);

    getCircle(n);
}
} 

int step[maxn * 2];
pii ans;
void dfs(int now, int fa) {
    step[now] = step[fa] + 1;
    ans = max(ans, make_pair(step[now], -now));
    for (int i = head[now]; i; i = edge[i].next) {
        if (edge[i].v == fa)
            continue;
        if (col[edge[i].v] == color)
            continue;
        dfs(edge[i].v, now);
    }
}
namespace Diameter {
tp diameter(int n) {
    fill(step + 1, step + 1 + n, 0);
    int s, t, l;
    tp res = make_tuple(2 * n + 1, 1, 1);

    for (int i = 1; i <= k; i++) { 
        col[a[i]] = n + 1;
        ans = make_pair(0, 0);
        dfs(a[i], 0);
        s = -ans.second;
        ans = make_pair(0, 0);
        dfs(s, 0);
        t = -ans.second;
        l = 2 * n - circle - (ans.first - 1);
        if (s > t)
            swap(s, t);
        res = min(res, make_tuple(l, s, t));
        col[a[i]] = color;
    }
    return res;
}
} 

int v[maxn * 2], w[maxn * 2];
namespace Chain {
pii q[maxn * 2];
int stdl, stdr;

tp chain(int n) {
    fill(step + 1, step + 1 + n, 0);
    for (int i = 1; i <= k; i++) {
        ans = make_pair(0, 0);
        dfs(a[i], 0);
        v[i] = -ans.second;
        w[i] = ans.first - 1;
    }  
    for (int i = 1; i <= k; i++) {
        v[i + k] = v[i];
        w[i + k] = w[i];
    }

    tp res = make_tuple(2 * n + 1, 0, 0);
    stdl = 1;
    stdr = 0;
    for (int i = 1; i < k; i++) {
        pii x = make_pair(w[i] - i, -i);
        while (stdr >= stdl && q[stdr] < x)
            stdr--;
        q[++stdr] = make_pair(w[i] - i, -i);
    }
    
    for (int i = k; i <= k * 2; i++) {
        int s = v[i], t = v[-q[stdl].second],
            l = 2 * n - 2 - (w[i] + i + q[stdl].first);
        if (s > t)
            swap(s, t);     
        res = min(res, make_tuple(l, s, t));
        pii x = make_pair(w[i] - i, -i);
        while (stdr >= stdl && q[stdr] < x)
            stdr--;
        while (stdr >= stdl && -q[stdl].second <= i - k + 1)
            stdl++;
        q[++stdr] = make_pair(w[i] - i, -i);
    }
    return res;
}
} 

int main() {
    int t, g = 0;
    t = io.read();
    while (t--) {
        int n;
        n = io.read();
        init(n);
        Read(n);

        Tarjan::Trajan(n);

        tp ans = Diameter::diameter(n);    
        ans = min(ans, Chain::chain(n));

        printf("Case #%d: %d %d %d\n", ++g, get<0>(ans), get<1>(ans),
               get<2>(ans));
    }

    return 0;
}