Blow up the city

Blow up the city

時間限制: 1 Sec  內存限制: 128 MB

題目描述

Country A and B are at war. Country A needs to organize transport teams to deliver supplies toward some command center cities.

In order to ensure the delivery works efficiently, all the roads in country A work only one direction. Therefore, map of country A can be regarded as DAG( Directed Acyclic Graph ). Command center cities only received supplies and not send out supplies.

Intelligence agency of country B is credibly informed that there will be two cities carrying out a critical transporting task in country A. 

As long as **any** one of the two cities can not reach a command center city, the mission fails and country B will hold an enormous advantage. Therefore, country B plans to destroy one of the n cities in country A and all the roads directly connected. (If a city carrying out the task is also a command center city, it is possible to destroy the city to make the mission fail)

Now country B has made q hypotheses about the two cities carrying out the critical task.
Calculate the number of plan that makes the mission of country A fail.
 

輸入

The first line contains a integer T (1≤T≤10), denoting the number of test cases.

In each test case, the first line are two integers n,m, denoting the number of cities and roads(1≤n≤100,000,1≤m≤200,000).
Then m lines follow, each with two integers u and v, which means there is a directed road from city u to v (1≤u,v≤n,u≠v).

The next line is a integer q, denoting the number of queries (1≤q≤100,000)
And then q lines follow, each with two integers a and b, which means the two cities carrying out the critical task are a and b (1≤a,b≤n,a≠b).

A city is a command center if and only if there is no road from it (its out degree is zero).

輸出

For each query output a line with one integer, means the number of plan that makes the mission of country A fail.

樣例輸入

2
8 8
1 2
3 4
3 5
4 6
4 7
5 7
6 8
7 8
2
1 3
6 7
3 2
3 1
3 2
2
1 2
3 1

樣例輸出

4
3
2
2

---

題意：有一個DAG，求有多少方案，使得割掉圖中一個點，圖上特定兩個點不能都到達出度爲0的點。
思路：反向建邊，鏈接超級源點到原圖中出度爲0的點。那麼題目就變成了：有一個DAG，求有多少種方案，使得割掉圖中一個點，從超級源點不能都到達兩個特定點。這就是支配樹問題。支配樹是一個有向圖抽象出來的樹，它知足某一點到根節點的路徑上的點，都是根結點在原圖中到達這個點的必經點。

#include<bits/stdc++.h>
#define N 100005
using namespace std;
 
struct ss
{
    int u,v,next;
};
ss edg[2*N];
int head[N],sum_edge=0;
 
void addedge(int u,int v)
{
    edg[sum_edge]=(ss){u,v,head[u]};
    head[u]=sum_edge++;
}
 
int grand[N][25]={0};
int depth[N],DEPTH;
 
void deal(int u,int v)
{
    grand[v][0]=u;
    depth[v]=depth[u]+1;
 
    for(int i=1;i<=DEPTH;i++)
    {
        grand[v][i]=grand[grand[v][i-1]][i-1];
    }
}
 
int lca(int a,int b)
{
    if(a==0||b==0)return a+b;
     
    if(depth[a]>depth[b])swap(a,b);
    for(int i=DEPTH;i>=0;i--)
    if(depth[a]<depth[b]&&depth[grand[b][i]]>=depth[a])b=grand[b][i];
 
    for(int i=DEPTH;i>=0;i--)
    if(grand[a][i]!=grand[b][i])
    {
        a=grand[a][i];
        b=grand[b][i];
    }
 
    if(a!=b)
    {
        return grand[a][0];
    }
    return a;
}
 
void init(int n)
{
    DEPTH=floor(log(n + 0.0) / log(2.0));
    memset(grand[0],0,sizeof(grand[0]));
    depth[0]=0;
    sum_edge=0;
    memset(head,-1,sizeof(head));
}
 
void getControl_tree(int n,int s)//從s出發能夠到達圖的全部點,s爲支配樹的根 
{
    int fa[N]={0};
    int rd[N]={0};
    stack<int>Stack;
    
    for(int i=1;i<=n;i++)
    for(int j=head[i];j!=-1;j=edg[j].next)rd[edg[j].v]++;
    
    Stack.push(s);
    
    while(!Stack.empty())
    {
        int x=Stack.top();
        Stack.pop();
        deal(fa[x],x);//建支配樹 
        
        for(int i=head[x];i!=-1;i=edg[i].next)
        {
            int v=edg[i].v;
            fa[v]=lca(fa[v],x);
            rd[v]--;
            if(!rd[v])Stack.push(v);
        }
    }
} 


int main()
{
     int t;
     scanf("%d",&t);
     while(t--)
     {
         int n,m;
         scanf("%d %d",&n,&m);
         init(n);
         
         int rd[N]={0};
         
         while(m--)
         {
            int u,v;
            scanf("%d %d",&u,&v);
            addedge(v,u);
            rd[u]++;
         }
         
         for(int i=1;i<=n;i++)if(!rd[i])addedge(n+1,i);
         getControl_tree(n+1,n+1);
         
         scanf("%d",&m);
         while(m--)
         {
             int u,v;
             scanf("%d %d",&u,&v);
             int LCA=lca(u,v);
             printf("%d\n",depth[u]+depth[v]-depth[LCA]-1-1+1);
         }
    }
    return 0;
}

View Code

支配樹參考博客：https://www.cnblogs.com/fenghaoran/p/dominator_tree.html