GCJ Round 1A 2016 C.BFFS

Problem

You are a teacher at the brand new Little Coders kindergarten. You have N kids in your class, and each one has a different student ID number from 1 through N. Every kid in your class has a single best friend forever (BFF), and you know who that BFF is for each kid. BFFs are not necessarily reciprocal -- that is, B being A's BFF does not imply that A is B's BFF.

Your lesson plan for tomorrow includes an activity in which the participants must sit in a circle. You want to make the activity as successful as possible by building the largest possible circle of kids such that each kid in the circle is sitting directly next to their BFF, either to the left or to the right. Any kids not in the circle will watch the activity without participating.

What is the greatest number of kids that can be in the circle?

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each test case consists of two lines. The first line of a test case contains a single integer N, the total number of kids in the class. The second line of a test case contains N integers F₁, F₂, ..., F_N, where F_i is the student ID number of the BFF of the kid with student ID i.

Output

For each test case, output one line containing "Case #x: y", where x is the test case number (starting from 1) and y is the maximum number of kids in the group that can be arranged in a circle such that each kid in the circle is sitting next to his or her BFF.

Limits

1 ≤ T ≤ 100.
1 ≤ F_i ≤ N, for all i.
F_i ≠ i, for all i. (No kid is their own BFF.)

Small dataset

3 ≤ N ≤ 10.

Large dataset

3 ≤ N ≤ 1000.

Sample

Input	Output
4 4 2 3 4 1 4 3 3 4 1 4 3 3 4 3 10 7 8 10 10 9 2 9 6 3 3	Case #1: 4 Case #2: 3 Case #3: 3 Case #4: 6

In sample case #4, the largest possible circle seats the following kids in the following order: 7 9 3 10 4 1. (Any reflection or rotation of this circle would also work.) Note that the kid with student ID 1 is next to the kid with student ID 7, as required, because the list represents a circle.

题意：

A有一个最好的朋友B，但B不一定认为A是他最好的朋友。每个人都拥有一个最好的朋友，若安排大家坐成一个环，每个人的左边或者右边必须坐自己最好的朋友，否则不能坐进这个环中。问这个环最多能容纳多少人。

分析：

最大的环有两种情况（假设此时最佳的环容纳了n人）：

1.n个人恰好头尾衔接组成一个圆环，此时情况最简单，无法在这个环中增加任何人，即最大的环最多容纳n人。

2.n个人并非头尾衔接，而是类似于A-B-C-D-C的情况，出现了两个人互相为最好的朋友，如例中C-D-C，构成了一个大小为2的头尾衔接的环，此时可在C与D两边各坐一名认为C（或认为D）是最好朋友的人，并依此找出这两个人能联合的最大长度。如例中C旁边是B,B-A,A此时已经有最好的朋友B在旁边，则另一边可接受一个非最好朋友X，X就是D另一边的尾部。此种情况相当于一个环带着两条边，结果就是2+两条边的长度。

代码先算情况1最大环大小，再算情况2最大环大小，最后取最大的。

#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <string>
#include <fstream>
#include <vector>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
#define INF 0x3f3f3f3f
const int N=1015;
const int mod=1e9+7;

int a[N],v[N],d[N];

int main() {
    int t,n,m,l,k;
    ifstream ifile;
    ofstream ofile;
    ofile.open("/Users/lijiechen/Downloads/outt.txt",ios::out);
    ifile.open("/Users/lijiechen/Downloads/C-large-practice.in.txt",ios::out);
    ifile>>t;
    int kase=0;
    while (t--) {
        ifile>>n;
        kase++;
        int ans=0;
        for (int i=1; i<=n; i++) {
            ifile>>a[i];
        }
        for (int i=1; i<=n; i++) {
            for (int j=1; j<=n; j++) {
                v[j]=0;
            }
            k=0;
            int flag=i;
            while (1) {
                v[flag]=1;
                flag=a[flag];
                k++;
                if (v[flag]) break;
            }
            if (flag==i) ans=max(ans, k);
        }
        for (int j=1; j<=n; j++) {
            v[j]=d[j]=0;
        }
        for (int j=1; j<=n; j++) {
            for (int i=1; i<=n; i++) {
                if (a[a[i]]!=i) d[a[i]]=max(d[a[i]], d[i]+1);
            }
        }
        int ans2=0;
        for (int i=1; i<=n; i++) {
            if (!v[i]&&a[a[i]]==i) {
                ans2+=2+d[i]+d[a[i]];
                v[i]=v[a[i]]=1;
            }
        }
        ans=max(ans, ans2);
        ofile<<"Case #"<<kase<<": "<<ans<<endl;
    }
    return 0;
}