树状数组+离散化——HDU 5877 （2016 ACM/ICPC Asia Regional Dalian Online 1010）

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

• 参考博客：
  http://blog.youkuaiyun.com/mymilkbottles/article/details/52497953

• 分析：
  给出N个点，常数值K，给出数组A表示每个节点的值。 再给出N-1条有向边u->v。求有多少组weak pair < u, v >，即满足：
  ①：u是v的祖先
  ②：A[u]*A[v]≤K
  的点对数量

• 题解：
  离散化处理：先处理A数组，对A数组进行排序后，用map记录下每个节点A值对应的排序后序号，然后用C数组记录下原序号对应的排序序号。

  树状数组：用vector存储好树后，同时记录下每个点的入度，入度为0的自然就是root。从root开始，先计算与root构成weak pair的节点的A值的排序序号，然后在树状数组中求和这个序号之前的节点数。然后把root节点的排序序号加入树状数组，再搜索root相连接的子节点，重复操作。PS：搜完一个节点的子节点后，需要将该节点从树状数组中删除。

• 参考代码：

/*************************************************************************
    > File Name: test.cpp
    > Author: Akira 
    > Mail: qaq.febr2.qaq@gmail.com 
 ************************************************************************/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <ctime>
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))
using namespace std;

#define MaxN 100005
#define MaxM MaxN*10
#define INF 0x3f3f3f3f
#define bug cout<<88888888<<endl;

int N;
LL K;

LL A[MaxN];//原数组
LL B[MaxN];//排序后数组
LL C[MaxN];//存储原来序号按值排序后的对应的序号
int Q[MaxN];
vector<int> vec[MaxN];
int in[MaxN];
map<LL,int> M;

int SUM(int nums)
{
    int Sum=0;
    while(nums)
    {
        Sum+=Q[nums];
        nums-=(nums&(-nums));
    }
    return Sum;
}

void UPDATA(int nums,int Add)
{
    while(nums<=N)
    {
        Q[nums]+=Add;
        nums+=(nums&(-nums));
    }
}

int Left,Right,Mid;
long long Pos;

int Find(long long val)   //在B中找到比 val 小的A值的序号
{
    Left=1,Right=N;
    while(Left<=Right)
    {
        Mid=(Left+Right)>>1;
        Pos=B[Mid];
       if(Pos==val)
            return Mid;
        else if(Pos>val)
            Right=Mid-1;
        else
            Left=Mid+1;
    }
    if(B[Left]>val) return Left-1;
    return Left;
}

long long DFS(int now) 
{
    int len=vec[now].size();
    long long ans=0;
    long long Nums=Find(K/A[now]);
    ans+=SUM(Nums);
    UPDATA(C[now],1);
    for(int i=0;i<len;++i)
    {
        ans+=DFS(vec[now][i]);
    }
    UPDATA(C[now],-1);
    return ans;
}

void init()
{
    M.clear();
    for(int i=1;i<=N;i++)
    {
        vec[i].clear();
    }
    CLR(in);
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d%lld", &N, &K);
        for(int i=1;i<=N;i++)
        {
            scanf("%lld", &A[i]);
            B[i] = A[i];
        }

        for(int i=1;i<N;i++)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            vec[u].push_back(v);
            in[v]++;
        }

        sort(B+1,B+1+N);
        for(int i=1;i<=N;i++)
            M[B[i]] = i;
        B[N+1] = 5e18;
        for(int i=1;i<=N;i++)
            C[i] = M[A[i]];     

        int root;
        for(int i=1;i<=N;++i)
        {
            if(!in[i])
            {
                root=i;break;
            }
        }
        CLR(Q);
        printf("%lld\n", DFS(root));

    }

    //system("pause");
}