【33.18%】【hdu 5877】Weak Pair (3种解法)

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)

Total Submission(s): 1637    Accepted Submission(s): 531

Problem Description

You are given a rooted tree
of N nodes,
labeled from 1 to N.
To the ith
node a non-negative value ai is
assigned.An ordered pair
of nodes (u,v) is
said to be weak if

  (1) u is
an ancestor of v (Note:
In this problem a node u is
not considered an ancestor of itself);

  (2) au×av≤k.



Can you find the number of weak pairs in the tree?

 

Input

There are multiple cases in the data set.

  The first line of input contains an integer T denoting
number of test cases.

  For each case, the first line contains two space-separated integers, N and k,
respectively.

  The second line contains N space-separated
integers, denoting a1 to aN.

  Each of the subsequent lines contains two space-separated integers defining an edge connecting nodes u and v ,
where node u is
the parent of node v.



  Constrains: 

  

  1≤N≤105 

  

  0≤ai≤109 

  

  0≤k≤1018

 

Output

For each test case, print a single integer on a single line denoting the number of weak pairs in the tree.

 

Sample Input

1
2 3
1 2
1 2

 

Sample Output

1

 

Source

2016 ACM/ICPC Asia Regional Dalian Online

 

【题解】

这道题的意思是，这两个条件同时满足才是一对weak pair，而不是说其中之一。

解法是，从根节点往下遍历树。

可以看到我们的遍历顺序是1->2->3.

然后我们把之前走过的点记在栈中(实际上dfs本身就是利用栈),然后走到3，之前的点就都是3的祖先了。

但是有个问题就是，当我们走到4之后。3也在栈中。而3不是4的祖先。于是我们要把3给退栈,实现方法如下。

void dfs(int x)

{

查找某种数据结构中小于等于k/a[x]的元素个数

把当前点加入到某种数据结构中

dfs(儿子);

把当前点从某种数据结构中退出来。

}

可以选用的数据结构

1.平衡树

平衡树的话应该就很好理解了吧。

就是把某个节点加入平衡树。查找小于m的值。然后把某个节点删掉。

这三个操作不会难。

(这里用的是SBT)

2.树状数组

因为ai过大。所以需要用到离散化的思想。

具体的实现方法:

seq[1..n]存a[1..n]

在seq[n+1..2*n]存k/a[i-n](i∈[n+1..2*n])，特殊的,如果a[i-n]==0,则seq[i] = INF.

然后把seq数组升序排。

然后当我们要找小于等于k/a[x]加入的时候。就在seq数组中索引k/a[x]的下标key。

因为k/a[x]也加进去了。所以如果要找小于等于k/a[x]的数则只要获取前缀和就可以了。

然后把a[x]加入，就索引seq中a[x]的下标key2.然后递增其值，然后修改与其相关的点。

把a[x]删去，就仍索引seq中a[x]的下标(其实已经索引过了就是key2),然后递减其值，再修改相关点。

3.线段树

仍然按照树状数组的方法离散化。然后就是把树状数组改成线段树了而已。单点递增。很容易的。直接递增答案query(1,key)即可;

【代码1】平衡树

#include <cstdio>
#include <cstring>
#include <vector>

const int MAXN = 100009;

using namespace std;

int T, n, father[MAXN], root_tree, root;
int si_ze[MAXN * 2], l[MAXN * 2], r[MAXN * 2], totn = 0;
__int64 key[MAXN * 2], k, seq[MAXN], ans = 0;
vector <int> son[MAXN];

void init()
{
	memset(father, 0, sizeof(father));
	for (int i = 1; i <= 100000; i++)
		son[i].clear();
	root = 0;
	totn = 0;
	ans = 0;
}

void input_data()
{
	scanf("%d%I64d", &n, &k);
	for (int i = 1; i <= n; i++)
		scanf("%I64d", &seq[i]);
	int u, v;
	for (int i = 1; i <= n - 1; i++)
	{
		scanf("%d%d", &u, &v);
		father[v] = u;
		son[u].push_back(v);
	}
	for (int i = 1; i <= n; i++)//找根节点
		if (father[i] == 0)
		{
			root_tree = i;
			break;
		}
}

void right_rotation(int &t)//右旋
{
	int k = l[t];
	l[t] = r[k];
	r[k] = t;
	si_ze[k] = si_ze[t];
	si_ze[t] = si_ze[l[t]] + si_ze[r[t]] + 1;
	t = k;
}

void left_rotation(int &t) //左旋
{
	int k = r[t];
	r[t] = l[k];
	l[k] = t;
	si_ze[k] = si_ze[t];
	si_ze[t] = si_ze[l[t]] + si_ze[r[t]] + 1;
	t = k;
}

void maintain(int &t, bool flag)
{
	if (flag)
	{
		if (si_ze[l[l[t]]] > si_ze[r[t]]) // 这是/型
			right_rotation(t);
		else
			if (si_ze[r[l[t]]] > si_ze[r[t]])//....
			{
				left_rotation(l[t]);
				right_rotation(t);
			}
			else
				return;//是平衡的就结束
	}
	else
	{
		if (si_ze[r[r[t]]] > si_ze[l[t]])
			left_rotation(t);
		else
			if (si_ze[l[r[t]]] > si_ze[l[t]])
			{
				right_rotation(r[t]);
				left_rotation(t);
			}
			else
				return;
	}
	maintain(l[t], true);
	maintain(r[t], false);
	maintain(t, true);
	maintain(t, false);
}

void insert(int &t, __int64 data2)
{
	if (t == 0)
	{
		t = ++totn;
		l[t] = r[t] = 0;
		si_ze[t] = 1;
		key[t] = data2;
	}
	else
	{
		si_ze[t]++;
		if (data2 < key[t])
			insert(l[t], data2);
		else
			insert(r[t], data2);
		maintain(t, data2 < key[t]);
	}
}

void de_lete(__int64 data2, int &t)
{
	si_ze[t]--;
	if (data2 == key[t])
	{
		bool flag1 = true, flag2 = true;//用于判断有无左右子树。
		if (l[t] == 0)
			flag1 = false;
		if (r[t] == 0)
			flag2 = false;
		if (!flag1 && !flag2)
			t = 0;
		else
			if (!flag1 && flag2)
				t = r[t];
			else
				if (flag1 && !flag2)
					t = l[t];
				else
					if (flag1 && flag2)
					{
						int temp = r[t];
						while (l[temp])
							temp = l[temp];
						key[t] = key[temp];
						de_lete(key[temp], r[t]);
					}
	}
	else
		if (data2 < key[t])
			de_lete(data2, l[t]);
		else
			de_lete(data2, r[t]);
}

__int64 find(__int64 what, int &t)
{
	if (t == 0)
		return 0;
	__int64 temp = 0;
	if (what >= key[t]) //左子树加上这个节点都小于等于what满足要求
	{
		temp += si_ze[l[t]] + 1;
		temp += find(what, r[t]);
	}
	else
		return find(what, l[t]);
	return temp;
}

void dfs(int rt)
{
	__int64 temp = k / seq[rt];
	if (seq[rt] == 0)
		temp = 2100000000;//这里temp本应改成1e19的，但是貌似也对了。。
	ans += find(temp, root);
	insert(root, seq[rt]);
	int len = son[rt].size();
	for (int i = 0; i <= len - 1; i++)
		dfs(son[rt][i]);
	de_lete(seq[rt], root);
}

void output_ans()
{
	printf("%I64d\n", ans);
}

int main()
{
	//freopen("F:\\rush.txt", "r", stdin);
	//freopen("F:\\rush_out.txt", "w", stdout);
	scanf("%d", &T);
	while (T--)
	{
		init();
		input_data();
		dfs(root_tree);
		output_ans();
	}
	return 0;
}

【代码2】树状数组

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

const int MAXN = 101000;
const long long INF = 10000000000000000000;

int c[MAXN * 2], a[MAXN], father[MAXN], n, lena;
long long seq[MAXN * 2], ans = 0, k;
vector <int> son[MAXN];

void init()
{
	ans = 0;
	memset(c, 0, sizeof(c));
	memset(father, 0, sizeof(father));
	for (int i = 1; i <= 100010; i++)
		son[i].clear();
}

void input_data()
{
	scanf("%d%I64d", &n, &k);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
		seq[i] = a[i];
	}
	for (int i = n + 1; i <= 2 * n; i++)
	{
		long long temp = a[i - n];
		if (a[i - n] == 0) //除0就改为无限大
			seq[i] = INF;
		else
			seq[i] = k / temp;
	}
	sort(seq + 1, seq + 1 + n * 2);
	//可能有重复的，但没关系,lower_bound返回的是一个特定值(seq是不会发生变化的)
	lena = 2 * n;
}

int lowbit(int x)
{
	return x & -x;
}

void dfs(int x)
{
	int key;
	if (a[x] == 0)
		key = lower_bound(seq + 1, seq + 1 + 2 * n, INF) - seq;
	else
		key = lower_bound(seq + 1, seq + 1 + 2 * n, k / a[x]) - seq;
	long long temp2 = 0;
	while (key)
	{
		temp2 += c[key];
		key = key - lowbit(key);
	}
	ans += temp2;
	key = lower_bound(seq + 1, seq + 1 + 2 * n, a[x]) - seq;
	int temp = key;
	while (temp <= lena)
	{
		c[temp]++;
		temp += lowbit(temp);
	}
	int len = son[x].size();
	for (int i = 0; i <= len - 1; i++)
		dfs(son[x][i]);
	while (key <= lena)
	{
		c[key]--;
		key += lowbit(key);
	}
}

void get_ans()
{
	int root = 1;
	for (int i = 1; i <= n - 1; i++)
	{
		int u, v;
		scanf("%d %d", &u, &v);
		father[v] = u;
		son[u].push_back(v);
	}
	for (int i = 1; i <= n; i++)
		if (father[i] == 0)
		{
			root = i;
		}
	dfs(root);
}

void output_ans()
{
	printf("%I64d\n", ans);
}

int main()
{
	//freopen("F:\\rush.txt", "r", stdin);
	//freopen("F:\\rush_out.txt", "w", stdout);
	int t;
	scanf("%d", &t);
	while (t--)
	{
		init();
		input_data();
		get_ans();
		output_ans();
	}
	return 0;
}

【代码3】线段树，基础的单点递增

#include <cstdio>
#include <algorithm>
#include <vector>
#define lson begin, m, rt << 1
#define rson m+1,end,rt<<1|1

using namespace std;

const int MAXN = 101000;
const long long INF = 10000000000000000000;

int  a[MAXN], father[MAXN], n, lena, sum[MAXN * 2 * 4]; //记住要开4倍
long long seq[MAXN * 2], ans = 0, k;
vector <int> son[MAXN];

void build(int begin, int end, int rt)
{
	sum[rt] = 0;
	if (begin == end)
		return;
	int m = (begin + end) >> 1;
	build(lson);
	build(rson);
}

void init()
{
	ans = 0;
	memset(father, 0, sizeof(father));
	for (int i = 1; i <= 100010; i++)
		son[i].clear();
}

void input_data()
{
	scanf("%d%I64d", &n, &k);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
		seq[i] = a[i];
	}
	for (int i = n + 1; i <= 2 * n; i++)
	{
		long long temp = a[i - n];
		if (a[i - n] == 0)
			seq[i] = INF;
		else
			seq[i] = k / temp;
	}
	sort(seq + 1, seq + 1 + n * 2);
	lena = 2 * n;
	build(1, lena, 1);
}

long long query(int l, int r, int begin, int end, int rt)//求区间和。
{
	if (l <= begin && end <= r)
		return sum[rt];
	int m = (begin + end) >> 1;
	long long temp = 0;
	if (l <= m)
		temp += query(l, r, lson);
	if (m < r)
		temp += query(l, r, rson);
	return temp;
}

void push_up(int rt)
{
	sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void updata(int pos, int num, int begin, int end, int rt)
{
	if (begin == end)
	{
		sum[rt] += num;
		return;
	}
	int m = (begin + end) >> 1;
	if (pos <= m)
		updata(pos, num, lson);
	else
		updata(pos, num, rson);
	push_up(rt);
}

void dfs(int x)
{
	int key;
	if (a[x] == 0)
		key = lower_bound(seq + 1, seq + 1 + 2 * n, INF) - seq;
	else
		key = lower_bound(seq + 1, seq + 1 + 2 * n, k / a[x]) - seq;
	long long temp2 = query(1, key, 1, lena, 1);
	ans += temp2;
	key = lower_bound(seq + 1, seq + 1 + 2 * n, a[x]) - seq;
	updata(key, 1, 1, lena, 1);
	int len = son[x].size();
	for (int i = 0; i <= len - 1; i++)
		dfs(son[x][i]);
	updata(key, -1, 1, lena, 1);
}

void get_ans()
{
	int root = 1;
	for (int i = 1; i <= n - 1; i++)
	{
		int u, v;
		scanf("%d %d", &u, &v);
		father[v] = u;
		son[u].push_back(v);
	}
	for (int i = 1; i <= n; i++)
		if (father[i] == 0)
		{
			root = i;
		}
	dfs(root);
}

void output_ans()
{
	printf("%I64d\n", ans);
}

int main()
{
	//freopen("F:\\rush.txt", "r", stdin);
	//freopen("F:\\rush_out.txt", "w", stdout);
	int t;
	scanf("%d", &t);
	while (t--)
	{
		init();
		input_data();
		get_ans();
		output_ans();
	}
	return 0;
}