[POI2008]枪战Maf

题目描述

有n个人，每个人手里有一把手枪。一开始所有人都选定一个人瞄准（有可能瞄准自己）。然后他们按某个顺序开枪，且任意时刻只有一个人开枪。因此，对于不同的开枪顺序，最后死的人也不同。

输入

输入n人数<1000000 每个人的aim

输出

你要求最后死亡数目的最小和最大可能

样例输入

8
2 3 2 2 6 7 8 5

样例输出

3 5

solution:
　　这个题调的让我想吐（太弱了QAQ），首先进行缩点，如果自杀min，max都加1，然后把它自己分一个点，如果是这个环点个数大于1切缩点后入度为0，min+=（num[i]+1）/2，max+=(num[i]-1)，还要考虑环缩点后入度不为0的情况，把所有点进行排序，先按照这点是否需要被处理，把需要被处理的放后面，（前面两种情况均已经处理不用再被处理），然后再按照入度从小到大排序，for循环找到第一个入度不为0且需要被处理的点，记录下标为ji，break。max+=n-ji+1。
　　 最小死亡比较难求，要找到第一个入读为零且需要处理的点，再找到最后一个入度为0且需要被处理的点，（其实就是ji-1），把这之间的点压入队列，把队列中要杀的人全部杀掉，看这些被杀的人的要杀的人的入度是否变为0，如果为0且每死亡继续入队，没杀一个min++，最后输出即可。
　　这题也可以树dp，但本蒟蒻没打出来，这题在cogs上交需要手动开大栈空间，否则会RE

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
using namespace std;
#define inf 0x7fffffff
__attribute__((optimize("O3")))int read() {
    int s=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0') {
        if(ch=='-') {
            f=-1;
        }
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        s=(s<<1)+(s<<3)+(ch^48);
        ch=getchar();
    }
    return s*f;
}
int n,r[1000005],tot;
struct node {
    int fr,to,next;
} c[2000005];
void add(int x,int y) {
    c[tot]=(node) {
        x,y,r[x]
    };
    r[x]=tot++;
}
int a[1000005],num[1000005],cnt,tim,dfn[1000005],low[1000005],p,belong[1000005],st[1000005];
bool in[1000005];
__attribute__((optimize("O3")))void tar(int x) {
    dfn[x]=low[x]=++tim;
    st[++p]=x;
    in[x]=1;
    for(int i=r[x]; ~i; i=c[i].next) {
        if(dfn[c[i].to]==-1) {
            tar(c[i].to);
            low[x]=min(low[x],low[c[i].to]);
        } else {
            if(in[c[i].to]) {
                low[x]=min(low[x],dfn[c[i].to]);
            }
        }
    }
    if(dfn[x]==low[x]) {
        int y;
        ++cnt;
        do {
            y=st[p--];
            in[y]=0;
            num[cnt]++;
            belong[y]=cnt;
        } while(x!=y);
    }
}
int min_ans,max_ans,indexx[1000005];
bool need_done[1000005],flag[1000005];
struct oo {
    int ord;
} point[1000005];// 1 chuliguo 0 meiyouchuli
__attribute__((optimize("O3")))bool cmp(oo a,oo b) {
    if(need_done[belong[a.ord]]>need_done[belong[b.ord]]) {
        return 0;
    }
    if(need_done[belong[a.ord]]<need_done[belong[b.ord]]) {
        return 1;
    }
    if(indexx[a.ord]<indexx[b.ord]) {
        return 1;
    }
    return 0;
}
int queue[1000005],head,tail;
bool die[1000005];
__attribute__((optimize("O3")))int main() {
    //freopen("maf10.in","r",stdin);
    //freopen("maf.out","w",stdout);
    /*int __size__= 128 << 20;
    char *__p__ = (char*)malloc(__size__) + __size__;
    __asm__("movl %0, %%esp\n" :: "r"(__p__));
    */
    n=read();
    cnt=0;
    memset(r,-1,sizeof(r));
    memset(dfn,-1,sizeof(dfn));
    for(int x,i=1; i<=n; i++) {
        a[i]=x=read();
        point[i].ord=i;
        if(a[i]==i) {
            min_ans++;
            max_ans++;
            belong[i]=++cnt;
            num[cnt]=1;
            die[i]=1;
            need_done[cnt]=0;
            continue;
        }
    }
    for(int i=1;i<=n;i++){
        int to=a[i];
        if(!die[i]&&!die[to]){
            indexx[to]++;
            add(i,to);
        }
    }
    for(int i=1; i<=n; i++) {
        if(dfn[i]==-1&&!die[i]) {
            tar(i);
        }
    }
    for(int i=0; i<tot; i++) {
        if(belong[c[i].fr]!=belong[c[i].to]) {
            need_done[belong[c[i].fr]]=1;
            need_done[belong[c[i].to]]=1;
        }
    }
    for(int i=1; i<=cnt; i++) {
        if(!need_done[i]&&num[i]>1) {
            max_ans+=num[i]-1;
            min_ans+=(num[i]+1)/2;
        }
    }
    sort(point+1,point+n+1,cmp);
    int ji=0;
    for(int i=1; i<=n; i++) {
        if(need_done[belong[point[i].ord]]&&indexx[point[i].ord]) {
            ji=i;
            break;
        }
    }
    max_ans+=n-ji+1;
    int pos1=inf;
    for(int i=1; i<=n; i++) {
        if(!indexx[point[i].ord]&&need_done[belong[point[i].ord]]) {
            pos1=i;
            break;
        }
    }
    for(int i=pos1; i<ji; i++) {
        queue[++tail]=point[i].ord;
    }
    while(head<tail) {
        int h=queue[++head];
        need_done[belong[h]]=0;
        if(die[a[h]]) {
            continue;
        }
        die[a[h]]=1;
        min_ans++;
        need_done[belong[a[h]]]=0;
        indexx[a[a[h]]]--;
        if(!indexx[a[a[h]]]&&!die[a[a[h]]]) {
            need_done[belong[a[a[h]]]]=0;
            queue[++tail]=a[a[h]];
        }
    }
    for(int i=1; i<=cnt; i++) {
        if(need_done[i]) {
            min_ans+=(num[i]+1)/2;
        }
    }
    printf("%d %d",min_ans,max_ans);
    return 0;
}