[BZOJ 1124][POI 2008] 枪战 Maf

1124: [POI2008]枪战Maf

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 659  Solved: 259
[Submit][Status][Discuss]

Description

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

Input

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

Output

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

Sample Input

8
2 3 2 2 6 7 8 5

Sample Output

3 5

不看数据范围可能看起来像是缩点树归的样子, 但是平常的 $O(n^2)$ 树归在这里显然需要 $\text{真-}Owys$ 才能过( $\text{-}Owys$大法好, $n^2$ 过 $5 \times 10^5$ )(雾

然后按照图论题的一般套路就该找规律了w(找不到规律就成了神tm不可做题了)

经过一波 $Tarjan$ 缩点后再YY我们可以得到以下结论:

首先对于最大死亡数来说:

当 $SCC$ 为一个点的最大死亡数在存在入边时为$1$, 否则为 $0$.

当 $SCC$ 为一个环的最大死亡数在存在入边时为 $SCC$ 中的结点数 $size$ , 否则为 $size-1$ (有一个点是无法杀死的)

当环存在入边时还要加上连入的环的结点数再减去其中的零入度结点(因为零入度结点不可能死亡).

然后是最小死亡数:

首先零入度结点必定无法杀死, 而零入度结点的目标必死. 所以我们可以在预处理时将零入度结点压入一个队列, 然后删除它和它的目标, 更新答案, 并将删掉的结点的目标的入度减去 $1$ . 因为杀死必死的人后可能它的目标的入度变成 $0$ 然后变成新的存活结点. 新的存活结点入队. 如此处理直至队列为空.

然后我们可以发现所有的链都会在这个过程中被处理掉, 也就是说图里应该删得只剩下几坨环了. 然后这时我们可以发现对于环来说, 若环中结点数为 $s$ , 则至少要死去 $\left \lceil \frac {s}{2} \right \rceil$ 个结点. (每次刚好隔开杀手, 隔一个死一个w)

如此处理即可求出最终解.

辣鸡分类讨论吃枣药丸(╯‵□′)╯︵┻━┻(雾

参考代码

GitHub

 #include <stack>
 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>

 const int MAXN=;

 int n;
 int scc;
 int Time;
 int maxA;
 int minA;
 int dfn[MAXN];
 int low[MAXN];
 int size[MAXN];
 int belong[MAXN];
 int target[MAXN];
 int inDegree[MAXN];
 int inDegreeSCC[MAXN];

 bool visited[MAXN];

 std::stack<int> s;

 void Initialize();
 void DFS(int);

 int main(){
     std::queue<int> live;
     Initialize();
     for(int i=;i<=n;i++){
         if(inDegree[i]==)
             live.push(i);
     }
     while(!live.empty()){
         int top=live.front();
         live.pop();
         visited[top]=true;
         if(visited[target[top]])
             continue;
         minA++;
         visited[target[top]]=true;
         if((--inDegree[target[target[top]]])==&&!visited[target[target[top]]])
             live.push(target[target[top]]);
     }
     for(int i=;i<=n;i++){
         int cnt=;
         if(!visited[i]){
             int x=i;
             do{
                 visited[x]=true;
                 cnt++;
                 x=target[x];
             }while(x!=i);
         }
         if(cnt>)
             minA+=(cnt+)/;
     }
     memset(visited,,sizeof(visited));
     for(int i=;i<=n;i++){
         if(dfn[i]==)
             DFS(i);
     }
     for(int i=;i<=n;i++){
         if(target[i]==i||belong[i]!=belong[target[i]])
             inDegreeSCC[belong[target[i]]]++;
     }
     for(int i=;i<=scc;i++){
         if(inDegreeSCC[i]>)
             maxA+=size[i];
         else
             maxA+=size[i]-;
     }
     printf("%d %d\n",minA,maxA);
     return ;
 }

 void DFS(int root){
     dfn[root]=low[root]=++Time;
     visited[root]=true;
     s.push(root);
     if(visited[target[root]]){
         low[root]=std::min(low[root],dfn[target[root]]);
     }
     else if(dfn[target[root]]==){
         DFS(target[root]);
         low[root]=std::min(low[root],low[target[root]]);
     }
     if(low[root]==dfn[root]){
         scc++;
         int top;
         do{
             top=s.top();
             belong[top]=scc;
             size[scc]++;
             visited[top]=false;
             s.pop();
         }while(top!=root);
     }
 }

 inline void Initialize(){
     scanf("%d",&n);
     for(int i=;i<=n;i++){
         scanf("%d",target+i);
         inDegree[target[i]]++;
     }
 }

Backup