[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=;
 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=;
         register char ch;
         do ch=getchar(); while (ch<'' || ch>'');
         do num=num*+ch-'', ch=getchar(); while (ch>='' && ch<='');
         return num;
     }
     inline void putint(int num, char ch='\n')
     {
         char stack[];
         register int top=;
         if (num==) stack[top=]='';
         for ( ;num;num/=) stack[++top]=num%+'';
         for ( ;top;top--) putchar(stack[top]);
         if (ch) putchar(ch);
     }
 }
 
 int n;
 int g[size][];
 int t, a[size];
 int f[size], d[size];
 int dp[size][];
 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=, ans2=;
 
     n=IOspace::getint();
     for (int i=;i<=n;i++)
     {
         f[i]=IOspace::getint(), d[f[i]]++;
         if (f[i]==i) ans2++, vis[i]=;
         E[f[i]]=newedge(i, E[f[i]]);
     }
 
     for (int i=;i<=n;i++) if (!d[i])
     {
         vis[i]=;
         ans2+=search(i);
     }
     for (int i=;i<=n;i++) if (!vis[i])
     {
         vis[i]=;
         ans2+=search(i);
     }
 
     memset(vis, , sizeof(vis));
     for (int i=;i<=n;i++) if (!vis[i])
     {
         vis[i]=;
         ans1+=find(i);
     }
 
     IOspace::putint(ans1, ' '); IOspace::putint(ans2);
 
     return ;
 }
 inline int search(int x)
 {
     int ret=;
     for (x=f[x];!vis[x];x=f[x]) vis[x]=, ret++;
     return ret;
 }
 inline void bfs(int x)
 {
     static int l, r, q[size];
 
     l=r=;
     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]=;
                 q[r++]=i->point;
             }
     }
 
     for (int i=r-;i>=;i--)
         if (E[q[i]]==NULL) dp[q[i]][]=inf;
         else if (E[q[i]]->next==NULL && loop[E[q[i]]->point]) dp[q[i]][]=((E[q[i]]->point)==q[i])?:inf;
         else
         {
             for (edge * j=E[q[i]];j;j=j->next)
                 if (!loop[j->point])
                     add(dp[q[i]][], dp[j->point][]);
             for (edge * j=E[q[i]];j;j=j->next)
                 if (!loop[j->point])
                     add(dp[q[i]][], min(dp[j->point][], dp[j->point][]));
             add(dp[q[i]][], );
         }
 }
 inline int find(int x)
 {
     int ret=;
 
     vis[x]=;
     for (x=f[x];!vis[x];x=f[x]) vis[x]=;
     for (t=;!loop[x];x=f[x]) loop[a[t++]=x]=;
     for (int i=;i<t;i++) bfs(a[i]);
     if (t==) return dp[a[]][];
     g[][]=dp[a[]][]; g[][]=inf;
     for (int i=;i<t;i++)
     {
         g[i][]=min(g[i-][], g[i-][]);
         add(g[i][], min(dp[a[i]][], dp[a[i]][]+));
         g[i][]=g[i-][];
         add(g[i][], dp[a[i]][]);
     }
     ret=g[t-][];
 
     g[][]=dp[a[]][]; g[][]=inf;
     for (int i=;i<t;i++)
     {
         g[i][]=min(g[i-][], g[i-][]);
         add(g[i][], min(dp[a[i]][], dp[a[i]][]+));
         g[i][]=g[i-][];
         add(g[i][], dp[a[i]][]);
     }
     ret=min(ret, min(g[t-][], g[t-][]));
 
     g[][]=dp[a[]][]+; g[][]=inf;
     for (int i=;i<t;i++)
     {
         g[i][]=min(g[i-][], g[i-][]);
         add(g[i][], min(dp[a[i]][], dp[a[i]][]+));
         g[i][]=g[i-][];
         add(g[i][], dp[a[i]][]);
     }
     ret=min(ret, g[t-][]);
 
     return ret;
 }

因为是考试时写的所以很长也是没办法的事系列