[USACO08DEC] Trick or Treat on the Farm

题目描述

每年万圣节，威斯康星的奶牛们都要打扮一番，出门在农场的N个牛棚里转 悠，来采集糖果.她们每走到一个未曾经过的牛棚，就会采集这个棚里的1颗糖果.

农场不大，所以约翰要想尽法子让奶牛们得到快乐.他给每一个牛棚设置了一个“后继牛 棚”.牛棚i的后继牛棚是next_i 他告诉奶牛们，她们到了一个牛棚之后，只要再往后继牛棚走去， 就可以搜集到很多糖果.事实上这是一种有点欺骗意味的手段，来节约他的糖果.

第i只奶牛从牛棚i开始她的旅程．请你计算，每一只奶牛可以采集到多少糖果．

输入输出格式

输入格式：

• Line 1: A single integer: N

• Lines 2..N+1: Line i+1 contains a single integer: next_i

输出格式：

• Lines 1..N: Line i contains a single integer that is the total number of unique stalls visited by cow i before she returns to a stall she has previously visited.

输入输出样例

输入样例#1：

4
1
3
2
3

输出样例#1：

1
2
2
3

说明

Four stalls.

• Stall 1 directs the cow back to stall 1.

• Stall 2 directs the cow to stall 3

• Stall 3 directs the cow to stall 2

• Stall 4 directs the cow to stall 3

Cow 1: Start at 1, next is 1. Total stalls visited: 1.

Cow 2: Start at 2, next is 3, next is 2. Total stalls visited: 2. Cow 3: Start at 3, next is 2, next is 3. Total stalls visited: 2. Cow 4: Start at 4, next is 3, next is 2, next is 3. Total stalls visited: 3.

• 本题n<=100000，首先考虑记忆化搜索，因为纯搜索在某些极端情况一定会被卡（n^2）。
• 但是记忆化搜索怎么实现呢？
• 通过观察样例发现，本题存在环。
• tarjan缩点+记忆化搜索。（大神说不用tarjan）。
• 所有环上的点的答案即为该环的长度，其余的点呢？因为其他的点都是指向某个环的，所以记忆化搜索即可（dp）。
• 期望得分100分。

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #define time dscada
 using namespace std;

 int n,l,cnt,top,next[],summ[],pre[],time,last[],other[],f[],dfn[],low[],stack[],huan[];
 bool cir[],vis[];

 void add(int u,int v) {
     pre[++l]=last[u];
     last[u]=l;
     other[l]=v;
 }

 void tarjan(int x) {
     dfn[x]=low[x]=++time;
     stack[++top]=x;
     vis[x]=;
     for (int p=last[x]; p; p=pre[p]) {
         int q=other[p];
         if (!dfn[q]) {
             tarjan(q);
             low[x]=min(low[x],low[q]);
         } else if (vis[q]) low[x]=min(low[x],dfn[q]);
     }
     if (dfn[x]==low[x]) {
         int sum=;
         cnt++;
         int now=stack[top--];
         cir[now]=;
         vis[now]=;
         huan[now]=cnt;
         sum++;
         while (now!=x) {
             now=stack[top--];
             cir[now]=;
             vis[now]=;
             huan[now]=cnt;
             sum++;
         }
         summ[cnt]=sum;
     }
 }

 int dfs(int x) {
     if (f[x]) return f[x];
     if (next[x]==x) {
         f[x]=;
         return f[x];
     }
     if (cir[x]) {
         f[x]=summ[huan[x]];
         return f[x];
     }
     if (cir[next[x]]) {
         f[x]=summ[huan[next[x]]]+;
         return f[x];
     }
     f[x]=dfs(next[x])+;
     return f[x];
 }

 int main() {
     scanf("%d",&n);
     for (int i=; i<=n; i++) {
         int x;
         scanf("%d",&x);
         next[i]=x;
         if (x!=i) add(i,x);//其实这里没有必要建边，用next数组即可。
     }
     for (int i=; i<=n; i++)
         if (!dfn[i]) tarjan(i);//tarjan缩点
     for (int i=; i<=n; i++) if (summ[huan[i]]==) cir[i]=;
     //for (int i=1; i<=n; i++) printf("%d\n",cir[i]);
     for (int i=; i<=n; i++) printf("%d\n",dfs(i));//记忆化搜索
     return ;
 }