AOJ2017（并查集，记录时间)

Problem F:
You are given a tree T that consists of N nodes. Each node is numbered from 1 to N, and node 1 is always the root node of T. Consider the following two operations on T:
M v: (Mark) Mark node v.
Q v: (Query) Print the index of the nearest marked ancestor of node v which is nearest to it. Initially, only the root node is marked.
Your job is to write a program that performs a sequence of these operations on a given tree and calculates the value that each Q operation will print. To avoid too large output file, your program is requested to print the sum of the outputs of all query operations. Note that the judges confirmed that it is possible to calculate every output of query operations in a given sequence.
Input
The input consists of multiple datasets. Each dataset has the following format:
The first line of the input contains two integers N and Q, which denotes the number of nodes in the tree Tand the number of operations, respectively. These numbers meet the following conditions: 1 ≤ N ≤ 100000 and 1 ≤ Q ≤ 100000.
The following N - 1 lines describe the configuration of the tree T. Each line contains a single integer pi (i= 2, … , N), which represents the index of the parent of i-th node.
The next Q lines contain operations in order. Each operation is formatted as “M v” or “Q v”, where v is the index of a node.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the sum of the outputs of all query operations in one line.
Sample Input
6 3
1
1
2
3
3
Q 5
M 3
Q 5
0 0
Output for the Sample Input
4
首先，再看oj题目的时候，应该对应数据量看看要求时间，这个题目给了8000ms，什么概念呢，也就是很长时间了，基本题目都会在1000，2000左右3000，都是比较多的了，8000也就是随意搞了呀！！
并查集做法一般都会要求压缩路径的，会有一些数据专门卡压缩路径的要求，这个题目就比较佛系了，就一组数据，时间充裕。
不压缩路径的做法（简单书写）

//并查集问题（不进行路径压缩的解法）
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#define MAXN 100005
using namespace std;
int val[MAXN];//并查集，表示是否连通

int mfind(int x){
    int r = x;
    while(r!=val[r]){
        r = val[r];
    }
    /*int i = x,j;
    while(i!=r){
        j = father[i];
        father[i] = r;
        i =j;
    }*/
    return r;//返回根节点
}
/*void connect(int x,int y){
    int nx = mfind(x);
    int ny = mfind(y);
    if(nx!=ny){
        father[nx] = ny;
    }
}*/
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m)&&m+n){
        val[1] = 1;
        for(int i=2;i<=n;i++){
            int temp;
            scanf("%d",&temp);
            val[i] = temp;
        }
        long long sum=0;//数字还是比较大的，估算 一下就知道int做不到
        char operation;
        int node;
        getchar();
        for(int i=0;i<m;i++){
            scanf("%c%d",&operation,&node);
            if(operation=='Q'){
                sum+=mfind(node);
            }
            else{
                val[node] = node;
            }
            getchar();
        }
        printf("%lld\n",sum);
    }
    return 0;
}

其实呢，我估计出题人呢，并不是想让我们这样求解 ，应该是记录时间，通过时间，对并查集进行路径压缩。
（其实我也是看了大佬们的题解才想到的，大佬威武）

//压缩路径代码，时间缩短明显
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <stack>
#include <vector>
using namespace std;
const int maxn=1e5+10;
bool vis[maxn];
int pre[maxn];
long long res;
bool flag;
int find(int x){
    int r = x;
    while(pre[r]!=r){
        if(!flag&&vis[pre[r]]){
            res += pre[r];
            flag = true;
            return -1;
        }
        r = pre[r];
    }
    return r;
}
void join(int a,int b){
    pre[b]=a;
}
int main(){
    int n,q,i,j,a,b;
    char op;
    while(~scanf("%d%d",&n,&q)&&n&&q){
        res = 0;
        memset(vis, false, sizeof(vis));
        for(i=1;i<=n;i++){
            pre[i] = i;
        }
        for(i=2;i<=n;i++){
            scanf("%d",&a);
            join(a,i);
        }
        getchar();
        for(i=1;i<=q;i++){
            scanf("%c %d",&op,&a);
            if(op=='Q'){
                if(!vis[a]){
                    flag = false;
                    if(find(a)==-1){
                    }else{
                        res += 1;
                    }
                }else{
                    res += a;
                }
            }else{
                vis[a] = true;
            }
            gechar();
        }
        printf("%lld\n",res)
    }
    return 0;
}