cactus仙人掌图【仙人掌圆方树+树形DP+单调队列】

题目链接 BZOJ 1023

---

  首先，圆方树是比较好想到的，维护直径，我们最方便的做法就是先让它变成一棵树，这里因为是仙人掌图，所以就用圆方树来构建。

  再者，就是维护直径了，比较好想到的是非环上结点，就是简单的树形dp就可以维护了。

  如果这个点是环上的一个点那又如何是好？那么，环上的两点所构成的最长直径为dp[u] + dp[v] + dis(u, v)，"dp[x]"表示x点到它下面的子树的最远距离，dis(u, v)表示在环上两点u、v的最短距离。

  其中，我们又可以知道环上两点的距离小于环大小的一半，所以我们可以根据这条信息来维护。

  于是，我们只考虑环位置上前面的点，并且在距离上必须小于环大小的一半，然后我们可以维护一个单调队列，保证单调递减，这样队首就是我们的最大答案可能。

#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 = 1e5 + 7;
int N, M;
struct Graph
{
    vector< pair<int, int> > vt[maxN];
    inline void addEddge(int u, int v, int w) { vt[u].push_back(MP(v, w)); }
    inline void _add(int u, int v, int w = 0) { addEddge(u, v, w); addEddge(v, u, w); }
    inline void clear() { for(int i=1; i<=N; i++) vt[i].clear(); }
} Old, Now;
int dfn[maxN], low[maxN], tot, Stap[maxN], Stop, dis[maxN], len[maxN], Bcnt;
bool instack[maxN] = {false};
vector<int> B_po[maxN];
inline void work(int u, int v)
{
    Bcnt++; B_po[Bcnt].clear();
    int p;
    len[Bcnt] = dis[Stap[Stop]] - dis[u] + 1;
    do
    {
        p = Stap[Stop--]; instack[p] = false;
        int d_1 = dis[p] - dis[u], d_2 = len[Bcnt] - d_1;
        Now._add(N + Bcnt, p, min(d_1, d_2));
        B_po[Bcnt].push_back(p);
    } while(p ^ v);
    Now._add(u, N + Bcnt);
}
void Tarjan(int u, int fa)
{
    dfn[u] = low[u] = ++tot;
    Stap[++Stop] = u;
    instack[u] = true;
    int len = (int)Old.vt[u].size();
    for(int i=0, v; i<len; i++)
    {
        v = Old.vt[u][i].first;
        if(v == fa) continue;
        if(!dfn[v])
        {
            dis[v] = dis[u] + 1;
            Tarjan(v, u);
            if(low[v] > dfn[u])
            {
                instack[Stap[Stop--]] = false;
                Now._add(u, v, 1);
            }
            else if(low[v] == dfn[u])
            {
                work(u, v);
            }
            low[u] = min(low[u], low[v]);
        }
        else if(instack[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
}
int dp[maxN] = {0}, ans, top, tail;
struct node
{
    int id, dis;
    node(int a=0, int b=0):id(a), dis(b) {}
} que[maxN];
void dfs(int u, int fa)
{
    if(u > N)
    {
        int len = (int)Now.vt[u].size(), Bid = u - N;
        for(int i=0, v, c; i<len; i++)
        {
            v = Now.vt[u][i].first; c = Now.vt[u][i].second;
            if(v == fa) continue;
            dfs(v, u);
            dp[u] = max(dp[u], dp[v] + c);
        }
        ans = max(ans, dp[u]);
        len = (int)B_po[Bid].size();
        int Tsiz = (len + 1) / 2;
        top = tail = 0;
        for(int i=0; i<len; i++)
        {
            while(top < tail && i - que[top].id > Tsiz) top++;
            if(top < tail) ans = max(ans, i - que[top].id + que[top].dis + dp[B_po[Bid][i]]);
            while(top < tail && i - que[tail - 1].id + que[tail - 1].dis <= dp[B_po[Bid][i]]) tail--;
            que[tail++] = node(i, dp[B_po[Bid][i]]);
        }
        for(int i=0; i<len; i++)
        {
            while(top < tail && len + 1 + i - que[top].id > Tsiz) top++;
            if(top < tail) ans = max(ans, len + 1 + i - que[top].id + que[top].dis + dp[B_po[Bid][i]]);
            while(top < tail && len + 1 + i - que[tail - 1].id + que[tail - 1].dis <= dp[B_po[Bid][i]]) tail--;
            que[tail++] = node(len + 1 + i, dp[B_po[Bid][i]]);
        }
    }
    else
    {
        int len = (int)Now.vt[u].size();
        for(int i=0, v, c; i<len; i++)
        {
            v = Now.vt[u][i].first; c = Now.vt[u][i].second;
            if(v == fa) continue;
            dfs(v, u);
            ans = max(ans, dp[u] + dp[v] + c);
            dp[u] = max(dp[u], dp[v] + c);
        }
    }
}
inline void init()
{
    tot = Stop = Bcnt = ans = 0;
//    Old.clear(); Now.clear();
}
int main()
{
    scanf("%d%d", &N, &M);
    init();
    for(int i=1, ki, las, x; i<=M; i++)
    {
        scanf("%d", &ki);
        las = 0;
        while(ki --)
        {
            scanf("%d", &x);
            if(las) Old._add(las, x, 1);
            las = x;
        }
    }
    Tarjan(1, 0);
    dfs(1, 0);
    printf("%d\n", ans);
    return 0;
}
/*
12 4
4 1 3 2 1
8 3 4 5 6 7 8 9 4
2 6 11
3 9 10 12
ans:6
7 1
10 1 2 3 1 4 5 1 6 7 1
ans:2
*/