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?
(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
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
【题解】
这道题的意思是，这两个条件同时满足才是一对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;
}
208
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
