bzoj 1023: [SHOI2008]cactus仙人掌图

    这道题是我做的第一道仙人掌DP，小小纪念一下……

    仙人掌DP就是环上的点环状DP，树上的点树上DP。就是说，做一遍DFS，DFS的过程中处理出环，环上的点先不DP，先把这些换上的点的后继点都处理出来，再从环上DFS序最小的点开始进行环状DP，就ok了。但是注意判断是不是父边不能用 v[k] != fa[now]，这样如果两个点构成一个环就会出错，所以存这个点的父边，记为fb[now]，这样判断的时候只需判断(k^1) != fb[now]，就可以了。在环状DP的时候我想了很久怎么用单调队列优化（其实是我太弱了，环状DP都不会写=_=）。存一个p[i] = f[i]-i，然后用 f[i]+i+p[j] 更新答案就可以了，最后只需更新环最顶端的点的 f 值而不用全部修改。

    这么说很笼统，还是看代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <stack>
#define N 500100
#define M 1001000
using namespace std;
 
int n, m;
int p[N], next[M], v[M], bnum = -1;
int f[N] = {0};
int ans = 0;
 
void addbian(int x, int y)
{
    bnum++; next[bnum] = p[x]; p[x] = bnum; v[bnum] = y;
    bnum++; next[bnum] = p[y]; p[y] = bnum; v[bnum] = x;
}
 
int nowtime = 0;
int low[N], vist[N] = {0}, fb[N], fa[N];
bool instack[N] = {0};
 
int roop[N], roopnum;
 
struct ss
{
    int place, val;
}dui[N];
int head, tail;
 
void work_circle()
{
    int limit = roopnum/2;
    for (int i = roopnum+1; i <= (roopnum<<1); ++i) roop[i] = roop[i-roopnum];
    ss x; x.val = f[roop[1]]-1; x.place = 1;
    head = 1; tail = 1; dui[head] = x;
    for (int i = 2; i <= (roopnum<<1); ++i)
    {
        while (dui[head].place+limit < i) head++;
        ans = max(ans, f[roop[i]]+i+dui[head].val);
        x.val = f[roop[i]]-i; x.place = i;
        while (dui[tail].val < x.val && tail >= head) tail--;
        dui[++tail] = x;
    }
}
 
void dfs(int now)
{
    int k = p[now]; vist[now] = ++nowtime; low[now] = vist[now];
    while (k != -1)
    {
        if (k != fb[now])
        {
            if (vist[v[k]]) low[now] = min(low[now], vist[v[k]]);
            else
            {
                fa[v[k]] = now; fb[v[k]] = k^1;
                dfs(v[k]);
                low[now] = min(low[now], low[v[k]]);
            }
        }
        k = next[k];
    }
    k = p[now];
    while (k != -1)
    {
        if ((k^1) == fb[v[k]] && low[v[k]] > vist[now])
        {
            ans = max(ans, f[now] + f[v[k]] + 1);
            f[now] = max(f[now], f[v[k]] + 1);
        }
        if ((k^1) != fb[v[k]] && vist[now] < vist[v[k]])
        {
            roopnum = 0;
            int x = v[k];
            while (x != fa[now])
            {
                roop[++roopnum] = x;
                x = fa[x];
            }
            work_circle();
            for (int i = 1; i < roopnum; ++i)
                f[now] = max(f[now], f[roop[i]]+min(i, roopnum-i));
        }
        k = next[k];
    }
}
 
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) p[i] = -1;
    for (int i = 1; i <= m; ++i)
    {
        int k, x, y; scanf("%d%d", &k, &x);
        for (int j = 1; j < k; ++j)
        {
            scanf("%d", &y);
            addbian(x, y);
            x = y;
        }
    }
    fa[1] = 0; fb[1] = -1; dfs(1);
    printf("%d\n", ans);
    return 0;
}