[DAG支配树(拓扑排序+LCA)] HDU6604 Blow up the city

Blow up the city

Time Limit: 5000/5000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 742    Accepted Submission(s): 393

 

Problem Description

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.

 

 

Input

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).

 

 

Output

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

 

 

Sample Input

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

 

 

Sample Output

4 3 2 2

 

 

Source

2019 Multi-University Training Contest 3

 

#include <bits/stdc++.h>
using namespace std;

const int mn = 1e5 + 10, mm = 2e5 + 10;

int n, m, ru[mn], tp[mn];
vector<int> to[mn], from[mn];
queue<int> tpque;
void tuopu_sort()
{
	for (int i = 1; i <= n; i++)
		if (ru[i] == 0)
		ru[i]++, to[0].push_back(i), from[i].push_back(0);
	tpque.push(0);
	int num = 0;
	while (!tpque.empty())
	{
		int u = tpque.front(); tpque.pop();
		tp[++num] = u;
		for (int i = to[u].size() - 1; i >= 0; i--)
		{
			int v = to[u][i];
			ru[v]--;
			if (ru[v] == 0) tpque.push(v);
		}
	}
}

int dep[mn], fa[mn][30];
int lca(int u, int v)
{
	if (dep[u] < dep[v]) swap(u, v);
	for (int i = 19; i >= 0; i--)
		if ((1 << i) <= dep[u] - dep[v]) u = fa[u][i];
	if (u == v) return u;
	for (int i = 19; i >= 0; i--)
		if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
	return fa[u][0];
}
vector<int> edge[mn];
void build_zhipeitree()
{
	/// i = 1 时,该题为超级源点,不用处理
	/// 且加入超级源点后点数变为 n + 1
	for (int i = 2; i <= n + 1; i++)	/// 拓扑序从小到大
	{
		int u = tp[i], v = from[u][0];
		for (int j = from[u].size() - 1; j > 0; j--) // 遍历点u在DAG中的父节点
			v = lca(v, from[u][j]);
		/// v 为点u的父节点们在支配树上的LCA
		edge[v].push_back(u);	/// 支配树建边
		
		/// 动态加点,用于查询LCA
		fa[u][0] = v;
		dep[u] = dep[v] + 1;
		for (int j = 1; j <= 19; j++)	// 更新u的祖节点
			fa[u][j] = fa[fa[u][j - 1]][j - 1];
	}
}

void init()
{
	for (int i = 0; i <= n; i++)
	{
		ru[i] = 0;
		from[i].clear();
		to[i].clear();
	}
}

int main()
{
	int T; scanf("%d", &T);
	while (T--)
	{
		scanf("%d %d", &n, &m);
		init();
		while (m--)
		{
			int u, v; scanf("%d %d", &u, &v);
			to[v].push_back(u); ru[u]++; // 建立DAG边 统计入度(拓扑排序)
			from[u].push_back(v); // 建立反向边(父节点们支配树上LCA时)
		}
		tuopu_sort();	/// 拓扑排序 保证拓扑序从小到大,在支配树上的深度也从浅到深
		build_zhipeitree();	/// 从根往叶子节点 构建支配树
		
		int Q; scanf("%d", &Q);
		while (Q--)
		{
			int u, v; scanf("%d %d", &u, &v);
			printf("%d\n", dep[u] + dep[v] - dep[lca(u, v)]);
		}
	}
	
	return 0;
}