hdu 5877 离散化+树状数组（2016大连网赛）

最新推荐文章于 2019-08-09 11:13:05 发布

原创最新推荐文章于 2019-08-09 11:13:05 发布 · 297 阅读

0 ·

CC 4.0 BY-SA版权

数据结构——树状数组/线段树专栏收录该内容

20 篇文章

订阅专栏

本文介绍了一种高效算法，用于解决有根树中特定条件下的节点对计数问题。通过对DFS序列进行优化，并利用树状数组进行维护，实现了O(nlogn)的时间复杂度。

题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=5877
题意：

n个节点的有根树，u是v的祖先，每个节点有个权值a[u].求 a[u] * a[v] <= k的有序对的数量。

分析：

这题一开始想到先求一下dfs序，然后把dfs序排列，二分找到每个结点的位置，然后在先前遍历找符合要求的点，时间复杂度O(n^2)，显然会超时~~
然后就想dfs过程中维护一个数据结构，把访问过的祖先节点的a都存起来，然后找比当前节点a值小的数的个数，求一下所有结点的和即可~~
因为数据范围很大，显然要离散化，顺便把k/a[i]也放进去，然后用树状数组维护一下即可。时间复杂度O（nlogn）

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <string>
#include <map>
#include <cmath>
#include <queue>
#include <set>

using namespace std;
typedef long long ll;
typedef pair<int, int>pii;
const double PI = acos (-1.0);
const int INF = 0x3f3f3f3f;
const int N = 2e5 + 9;
ll a[N];
int vis[N], head[N], p[N], c[N];
ll k, ans;
int n, cnt, tot;
struct Edge {
    int v,  next;
} edge[N];

void addedge (int u, int  v) {
    edge[tot].v = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int lowbit (int x) {
    return x & (-x);
}
void update (int x, int val, int n) {
    for (int i = x; i <= n; i += lowbit (i) )
        c[i] += val;
}
int getsum (int x) {
    int ans = 0;
    for (int i = x; i > 0; i -= lowbit (i) )
        ans += c[i];
    return ans;
}
void dfs (int u) {
    int pos = a[u + n];
    ans += getsum (pos);
    update (a[u], 1, n + n);
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].v;
        dfs (v);
    }
    update (a[u], -1, n + n);
}
bool cmp (int x, int y) {
    if (a[x] == a[y]) return x < y;
    return a[x] < a[y];
}

int main() {
    //freopen ("f.txt", "r", stdin);
    int u, v;
    int T;
    scanf ("%d", &T);
    while (T--) {
        scanf ("%d%lld", &n, &k);
        memset (head, -1, sizeof (head) );
        memset (vis, 0, sizeof (vis) );
        ans = 0;
        tot = 0;

        for (int i = 1; i <= n; i++) {
            scanf ("%lld", &a[i]);
            if (a[i] == 0) a[n + i] = INF;
            else a[n + i] = k / a[i];
            p[i] = i;
            p[n + i] = n + i;
        }
        sort (p + 1, p + 1 + n + n, cmp);

        for (int i = 1; i <= n + n; i++) a[p[i]] = i;

        for (int i = 0; i < n - 1; i++) {
            scanf ("%d%d", &u, &v);
            addedge (u, v);
            vis[v]++;
        }
        for (int i = 1; i <= n; i++) if (vis[i] == 0) {
                u = i;
                break;
            }
        dfs (u);
        printf ("%lld\n", ans);
    }
    return 0;
}