[APIO2018] 铁人两项【圆方树+树形DP】

题目链接 BZOJ 5463

---

  首先，这道题的关键就是在于走环与直接走之间的差别。

  很容易发现的是，我们可以通过枚举中间点来进行考虑，如果把这道题放到树上去，也就是原图是一棵树的话，那么很容易就能列写出对应的树形DP，通过维护子结点的size，我们构造起点和终点的可能性。如此，能解决所有的圆点上的问题。

  现在的问题，就在于原图中存在环的情况，有环可怎么办呢？譬如说，我们现在取到的中间点是环上一点，那么起点和终点可以是环上任意两点的延伸线上的各个点，怎么理解？取中间点为环上某点，那么除去起点和终点，环上减去两点，也就是“环的点数-2”就是我们可以选择的中间点的可能性，然后呢，起点和终点也可以是环上的某个点的延长线方向，其中，特殊的作为环上一点、却为圆方树父亲的点是在反向延长线方向。这里就是用树形DP的基本操作即可完成相应任务。

  具体，可以看看方程。

void dfs(int u, int fa)
{
    siz[u] = 0;
    for(int i=Now.head[u], v; ~i; i=Now.edge[i].nex)
    {
        v = Now.edge[i].to;
        if(v == fa) continue;
        dfs(v, u);
        if(u <= N) ans += 1LL * siz[u] * siz[v];
        else ans += 1LL * siz[u] * siz[v] * (Bsiz[u - N] - 2LL);
        siz[u] += siz[v];
    }
    if(u <= N)
    {
        siz[u]++;
        ans += 1LL * (all - siz[u]) * (siz[u] - 1LL);
    }
    else
    {
        ans += 1LL * (all - siz[u]) * siz[u] * (Bsiz[u - N] - 2LL);
    }
}

  这就是我构造圆方树的主要方程。

At last，这是一道蛮好的题目。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define eps 1e-8
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
#define MAX_3(a, b, c) max(a, max(b, c))
#define Rabc(x) x > 0 ? x : -x
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7, maxM = 4e5 + 7;
int N, M, Q;
struct Graph
{
    int head[maxN], cnt;
    struct Eddge
    {
        int nex, to;
        Eddge(int a=-1, int b=0):nex(a), to(b) {}
    }edge[maxM];
    inline void addEddge(int u, int v)
    {
        edge[cnt] = Eddge(head[u], v);
        head[u] = cnt++;
    }
    inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
    void clear()
    {
        cnt = 0;
        for(int i=1; i<=N; i++) head[i] = -1;
    }
} Old, Now;
int dfn[maxN], tot, low[maxN], Stap[maxN], Stop, Bcnt, Bsiz[maxN];
ll all;
void Tarjan(int u, int fa)
{
    dfn[u] = low[u] = ++tot; all++;
    Stap[++Stop] = u;
    for(int i=Old.head[u], v, p; ~i; i=Old.edge[i].nex)
    {
        v = Old.edge[i].to;
        if(v == fa) continue;
        if(!dfn[v])
        {
            Tarjan(v, u);
            if(low[v] == dfn[u])
            {
                Bcnt++; Now.head[N + Bcnt] = -1; Bsiz[Bcnt] = 0;
                do
                {
                    p = Stap[Stop--];
                    Now._add(p, N + Bcnt);
                    Bsiz[Bcnt]++;
                } while(p ^ v);
                Now._add(u, N + Bcnt);
                Bsiz[Bcnt]++;
            }
            else if(low[v] > dfn[u])
            {
                Stop--;
                Now._add(u, v);
            }
            low[u] = min(low[u], low[v]);
        }
        else low[u] = min(low[u], dfn[v]);
    }
}
ll siz[maxN] = {0}, ans = 0;
void dfs(int u, int fa)
{
    siz[u] = 0;
    for(int i=Now.head[u], v; ~i; i=Now.edge[i].nex)
    {
        v = Now.edge[i].to;
        if(v == fa) continue;
        dfs(v, u);
        if(u <= N) ans += 1LL * siz[u] * siz[v];
        else ans += 1LL * siz[u] * siz[v] * (Bsiz[u - N] - 2LL);
        siz[u] += siz[v];
    }
    if(u <= N)
    {
        siz[u]++;
        ans += 1LL * (all - siz[u]) * (siz[u] - 1LL);
    }
    else
    {
        ans += 1LL * (all - siz[u]) * siz[u] * (Bsiz[u - N] - 2LL);
    }
}
inline void init()
{
    Old.clear(); Now.clear();
    tot = Stop = Bcnt = 0;
}
int main()
{
    scanf("%d%d", &N, &M);
    init();
    for(int i=1, u, v; i<=M; i++)
    {
        scanf("%d%d", &u, &v);
        Old._add(u, v);
    }
    for(int i=1; i<=N; i++)
    {
        if(!dfn[i])
        {
            all = 0;
            Tarjan(i, 0);
            dfs(i, 0);
        }
    }
    printf("%lld\n", ans * 2LL);
    return 0;
}