[POI 2008]Mafia

这题目写了我好长时间，但还是几乎(不要在意细节)一遍 A 了喵~

据说有代码奇短的，Orz 思路巧妙的大爷

想我这种 Brute Force 写写的傻 X 真是代码量飞起来了耶，喵~

如果把每个人看成点，每个人要 kill 的人向此人连出一条有向边，那么每个点仅有一条出边和一条入边

经验告诉我们，这就是 环+内向图 的节奏

经验又告诉我，处理这种图要么先暴力搞环，再搞挂在环上的树。要么先搞树，再弄环。

此题显然是后者

环+内向图只需要用 bfs 就可以搞出来了，看到写 tarjan 的真是 Orz 

弄出 环 和 树 后，先在树上跑 dp，用 dp[u][0] 表示如果 u 最后被 kill 了，那么以 u 为根子树最少要死几人， dp[u][1] 是 u 存活下来的情况

这是普及组难度的树形 dp 吧喵~

再在环上跑 dp ，我们先破环为链，则有3种情况 (我们令在首的人为 A , 在尾的人为 B)

1. A君 最后活着，那 B君 一定被 kill 了

2. A君 最后被 kill 了，B君 存活了或也被 kill 了

3. A君 存活了下来，B君 也存活了下来，然后 B君 kill A君

三种情况要分类讨论

中间过程的状态转移和以上三种情况类似，无非就是讨论 i 君 和 i+1 君 的是否被 kill 的关系  (妈妈说，某个字打出来是不好的喵~)

被 kill 有两种可能:1.被自己的子树中的某君 kill 了  2.被环上的某君 kill 了

这个 dp 也很好想嘛

似乎除了难写就没有难度了喵？

#include <cstdio>
#include <cstring>
const int size=1000001;
const int inf=size;

namespace IOspace
{
    inline void assign() {freopen("isaac.in", "r", stdin); freopen("isaac.out", "w", stdout);}
    inline void close() {fclose(stdin); fclose(stdout);}
    inline int getint()
    {
        register int num=0;
        register char ch;
        do ch=getchar(); while (ch<'0' || ch>'9');
        do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
        return num;
    }
    inline void putint(int num, char ch='
')
    {
        char stack[15];
        register int top=0;
        if (num==0) stack[top=1]='0';
        for ( ;num;num/=10) stack[++top]=num%10+'0';
        for ( ;top;top--) putchar(stack[top]);
        if (ch) putchar(ch);
    }
}

int n;
int g[size][2];
int t, a[size];
int f[size], d[size];
int dp[size][2];
bool vis[size], loop[size];

struct edge {int point; edge * next;};
edge MEM[size], * PORT=MEM;
edge * E[size];
inline edge * newedge(int _point, edge * _next)
    {edge * ret=PORT++; ret->point=_point; ret->next=_next; return ret;}

inline int min(int x, int y) {return x<y?x:y;}
inline int max(int x, int y) {return x>y?x:y;}
inline void add(int & x, int y) {if (x>=inf || y>=inf) x=inf; else x+=y;}
inline int search(int);
inline int find(int);
inline void bfs(int);

int main()
{
    int ans1=0, ans2=0;

    n=IOspace::getint();
    for (int i=1;i<=n;i++)
    {
        f[i]=IOspace::getint(), d[f[i]]++;
        if (f[i]==i) ans2++, vis[i]=1;
        E[f[i]]=newedge(i, E[f[i]]);
    }

    for (int i=1;i<=n;i++) if (!d[i])
    {
        vis[i]=1;
        ans2+=search(i);
    }
    for (int i=1;i<=n;i++) if (!vis[i])
    {
        vis[i]=1;
        ans2+=search(i);
    }

    memset(vis, 0, sizeof(vis));
    for (int i=1;i<=n;i++) if (!vis[i])
    {
        vis[i]=1;
        ans1+=find(i);
    }

    IOspace::putint(ans1, ' '); IOspace::putint(ans2);

    return 0;
}
inline int search(int x)
{
    int ret=0;
    for (x=f[x];!vis[x];x=f[x]) vis[x]=1, ret++;
    return ret;
}
inline void bfs(int x)
{
    static int l, r, q[size];

    l=r=0;
    for (q[r++]=x;l<r; )
    {
        int u=q[l++];
        for (edge * i=E[u];i;i=i->next)
            if (!loop[i->point])
            {
                vis[i->point]=1;
                q[r++]=i->point;
            }
    }

    for (int i=r-1;i>=0;i--)
        if (E[q[i]]==NULL) dp[q[i]][0]=inf;
        else if (E[q[i]]->next==NULL && loop[E[q[i]]->point]) dp[q[i]][0]=((E[q[i]]->point)==q[i])?1:inf;
        else
        {
            for (edge * j=E[q[i]];j;j=j->next)
                if (!loop[j->point])
                    add(dp[q[i]][1], dp[j->point][0]);
            for (edge * j=E[q[i]];j;j=j->next)
                if (!loop[j->point])
                    add(dp[q[i]][0], min(dp[j->point][0], dp[j->point][1]));
            add(dp[q[i]][0], 1);
        }
}
inline int find(int x)
{
    int ret=0;

    vis[x]=1;
    for (x=f[x];!vis[x];x=f[x]) vis[x]=1;
    for (t=0;!loop[x];x=f[x]) loop[a[t++]=x]=1;
    for (int i=0;i<t;i++) bfs(a[i]);
    if (t==1) return dp[a[0]][0];
    g[0][1]=dp[a[0]][1]; g[0][0]=inf;
    for (int i=1;i<t;i++)
    {
        g[i][0]=min(g[i-1][0], g[i-1][1]);
        add(g[i][0], min(dp[a[i]][0], dp[a[i]][1]+1));
        g[i][1]=g[i-1][0];
        add(g[i][1], dp[a[i]][1]);
    }
    ret=g[t-1][0];

    g[0][0]=dp[a[0]][0]; g[0][1]=inf;
    for (int i=1;i<t;i++)
    {
        g[i][0]=min(g[i-1][0], g[i-1][1]);
        add(g[i][0], min(dp[a[i]][0], dp[a[i]][1]+1));
        g[i][1]=g[i-1][0];
        add(g[i][1], dp[a[i]][1]);
    }
    ret=min(ret, min(g[t-1][0], g[t-1][1]));

    g[0][0]=dp[a[0]][1]+1; g[0][1]=inf;
    for (int i=1;i<t;i++)
    {
        g[i][0]=min(g[i-1][0], g[i-1][1]);
        add(g[i][0], min(dp[a[i]][0], dp[a[i]][1]+1));
        g[i][1]=g[i-1][0];
        add(g[i][1], dp[a[i]][1]);
    }
    ret=min(ret, g[t-1][1]);

    return ret;
}