zoukankan      html  css  js  c++  java
  • HDU 5792 World is Exploding (树状数组)

    World is Exploding

    题目链接:

    http://acm.hdu.edu.cn/showproblem.php?pid=5792

    Description

    Given a sequence A with length n,count how many quadruple (a,b,c,d) satisfies: a≠b≠c≠d,1≤a < b≤n,1≤c < d≤n,Aa < Ab,Ac > Ad. ##Input The input consists of multiple test cases. Each test case begin with an integer n in a single line. The next line contains n integers A1,A2⋯An. 1≤n≤50000 0≤Ai≤1e9 ##Output For each test case,output a line contains an integer. ##Sample Input 4 2 4 1 3 4 1 2 3 4 ##Sample Output 1 0 ##Source 2016 Multi-University Training Contest 5
    ##题意: 找出有多少个四元组(a,b,c,d)满足a≠b≠c≠d,a < b,c < d,Aa < Ab,Ac > Ad.
    ##题解: 下面将题意中的Aa < Ab称为升序对,Ac > Ad称为降序对. 首先会想到如果没有a≠b≠c≠d的限制,那么可以分别找到所有升序对和降序对数目相乘. 所以在有a≠b≠c≠d限制的情况下,需要考虑去重. 枚举元素num[i],考虑以num[i]为升序对右边界的情况: 1. 以num[i]为右边界的升序对个数为:1~i-1中比i小的个数. 2. 降序对:所有降序对 - 包含升序对中元素的降序对. 3. 包含升序对中元素的降序对:Sum((右边比num[j]小 + 左边比num[j]大) + (右边比num[i]小 + 左边比num[i]大)). (j为1~i-1中比num[i]小的数).
    接下来的任务是:求出任一数左边比它大、小,右边比它大、小的数的个数各是多少. 这里可以用求逆序数的方法来求. 先将数据离散化. 注意TLE:尽量使用一次树状数组或线段树操作(O(nlogn)) + 多个O(n)的遍历来求得上述四个数组. 若分别使用2次甚至更多次的的线段树操作,将会由于常数太大而TLE(TLE代码附后,使用三次线段树操作).
    分别使用left_large,left_small,right_small,right_large来表示上述的四个量. all_less为全部降序对数. 那么结果为: left_small[i] * all_less - Σ(left_large[i]+right_small[i], left_large[j]+right_small[j]); (其中j为i左边比num[i]小的数,其个数为left_small[i]). 优化:若是直接用上述式子来求,则要再维护一次树状数组求比num[i]小的数的所涉及的重复降序对. 实际上,对于每个num[i],在减号右边left_large[i]+right_small[i]被计数的次数应该是i的右边比num[i]大的数的个数. 所以上式可优化为代码所示的式子:(总共仅需一次树状数组操作) ans += left_small[i] * (all_less - left_large[i] - right_small[i]); ans -= right_large[i] * (left_large[i] + right_small[i]);

    ##代码: ``` cpp #include #include #include #include #include #include #include #include #include #define LL long long #define mid(a,b) ((a+b)>>1) #define eps 1e-8 #define maxn 55000 #define mod 1000000007 #define inf 0x3f3f3f3f #define IN freopen("in.txt","r",stdin); using namespace std;

    int n;
    LL num[maxn], tmpa[maxn];
    LL c[maxn];
    LL left_large[maxn], left_small[maxn];
    LL right_small[maxn], right_large[maxn];
    LL tol_cnt[maxn], tol_small[maxn], tol_large[maxn];

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

    void update(LL x, LL d) {
    while(x <=n) {
    c[x] += d;
    x += lowbit(x);
    }
    }

    LL get_sum(LL x) {
    LL ret = 0;
    while(x > 0) {
    ret += c[x];
    x -= lowbit(x);
    }
    return ret;
    }

    int main(int argc, char const *argv[])
    {
    //IN;

    while(scanf("%d", &n) != EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%d", &num[i]), tmpa[i] = num[i];
        sort(tmpa+1, tmpa+1+n);
    
        map<LL, LL> mymap;
        LL sz = 0; mymap.clear();
        for(int i=1; i<=n; i++) {
            if(!mymap.count(tmpa[i])) {
                sz++;
                mymap.insert(make_pair(tmpa[i], sz));
            }
        }
    
        for(int i=1; i<=n; i++) {
            num[i] = mymap[num[i]];
        }
    
        memset(left_large, 0, sizeof(left_large));
        memset(right_large, 0, sizeof(right_large));
        memset(right_small, 0, sizeof(right_small));
        memset(left_small, 0, sizeof(left_small));
        memset(tol_small, 0, sizeof(tol_small));
        memset(tol_large, 0, sizeof(tol_large));
        memset(tol_cnt, 0, sizeof(tol_cnt));
        memset(c, 0, sizeof(c));
    
        for(int i=1; i<=n; i++) {
            tol_cnt[num[i]]++;
        }
        for(int i=1; i<=sz; i++) {
            tol_small[i] = tol_small[i-1] + tol_cnt[i-1];
        }
        for(int i=sz; i>=1; i--) {
            tol_large[i] = tol_large[i+1] + tol_cnt[i+1];
        }
    
        LL all_less = 0;
        for(int i=1; i<=n; i++) {
            left_large[i] = get_sum(sz) - get_sum(num[i]);
            right_large[i] = tol_large[num[i]] - left_large[i];
    
            left_small[i] = get_sum(num[i]-1);
            right_small[i] = tol_small[num[i]] - left_small[i];
    
            all_less += right_small[i];
    
            update(num[i], 1);
        }
    
        LL ans = 0;
        for(int i=1; i<=n; i++) {
            ans += left_small[i] * (all_less - left_large[i] - right_small[i]);
            ans -= right_large[i] * (left_large[i] + right_small[i]);
        }
    
        printf("%I64d
    ", ans);
    }
    
    return 0;
    

    }

    
    ####TLE代码:(三次线段树操作)
    ``` cpp
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <algorithm>
    #include <queue>
    #include <map>
    #include <set>
    #include <vector>
    #define LL long long
    #define mid(a,b) ((a+b)>>1)
    #define eps 1e-8
    #define maxn 55000
    #define mod 1000000007
    #define inf 0x3f3f3f3f
    #define IN freopen("in.txt","r",stdin);
    using namespace std;
    
    int n;
    LL num[maxn], tmpa[maxn];
    LL pre[maxn];
    LL last[maxn];
    
    struct Tree
    {
        int left,right;
        LL cur;
        LL sum;
    }tree[maxn<<2];
    
    void build(int i,int left,int right)
    {
        tree[i].left=left;
        tree[i].right=right;
    
        if(left==right){
            tree[i].sum = 0;
            tree[i].cur = 0;
            return ;
        }
    
        int mid=mid(left,right);
    
        build(i<<1,left,mid);
        build(i<<1|1,mid+1,right);
    
        tree[i].sum=tree[i<<1].sum+tree[i<<1|1].sum;
        tree[i].cur=tree[i<<1].cur+tree[i<<1|1].cur;
    }
    
    void update(int i,int x,LL d)
    {
        if(tree[i].left==tree[i].right){
            tree[i].sum+=1;
            tree[i].cur+=d;
            return;
        }
    
        int mid=mid(tree[i].left,tree[i].right);
    
        if(x<=mid) update(i<<1,x,d);
        else update(i<<1|1,x,d);
    
        tree[i].sum=tree[i<<1].sum+tree[i<<1|1].sum;
        tree[i].cur=tree[i<<1].cur+tree[i<<1|1].cur;
    }
    
    LL query(int i,int left,int right)
    {
        if(tree[i].left==left&&tree[i].right==right)
            return tree[i].sum;
    
        int mid=mid(tree[i].left,tree[i].right);
    
        if(right<=mid) return query(i<<1,left,right);
        else if(left>mid) return query(i<<1|1,left,right);
        else return query(i<<1,left,mid)+query(i<<1|1,mid+1,right);
    }
    
    LL query2(int i,int left,int right)
    {
        if(tree[i].left==left&&tree[i].right==right)
            return tree[i].cur;
    
        int mid=mid(tree[i].left,tree[i].right);
    
        if(right<=mid) return query2(i<<1,left,right);
        else if(left>mid) return query2(i<<1|1,left,right);
        else return query2(i<<1,left,mid)+query2(i<<1|1,mid+1,right);
    }
    
    map<LL, LL> mymap;
    
    int main(int argc, char const *argv[])
    {
        //IN;
    
        while(scanf("%d", &n) != EOF)
        {
            for(int i=1; i<=n; i++)
                scanf("%d", &num[i]), tmpa[i] = num[i];
            sort(tmpa+1, tmpa+1+n);
    
            LL sz = 0; mymap.clear();
            for(int i=1; i<=n; i++) {
                if(!mymap.count(tmpa[i])) {
                    sz++;
                    mymap.insert(make_pair(tmpa[i], sz));
                }
            }
    
            for(int i=1; i<=n; i++) {
                num[i] = mymap[num[i]];
            }
    
            fill(pre, pre+n+1, 0);
            fill(last, last+n+1, 0);
    
            build(1, 1, sz);
            for(int i=1; i<=n; i++) {
                update(1, num[i], 1);
                if(num[i] == sz) continue;
                pre[i] = query(1, num[i]+1, sz);
            }
            build(1, 1, sz);
            for(int i=n; i>=1; i--) {
                update(1, num[i], 1);
                if(num[i] == 1) continue;
                last[i] = query(1, 1, num[i]-1);
            }
    
            LL all_less  = 0;
            for(int i=1; i<=n; i++) {
                all_less += last[i];
            }
    
            build(1, 1, sz);
            LL ans = 0;
            for(int i=1; i<=n; i++) {
                update(1, num[i], pre[i]+last[i]);
                if(num[i] == 1) continue;
                LL pre_num = query(1, 1, num[i]-1);
                LL pre_sum = query2(1, 1, num[i]-1);
    
                ans += pre_num * (all_less - pre[i] - last[i]) - pre_sum;
            }
    
            printf("%I64d
    ", ans);
        }
    
        return 0;
    }
    
  • 相关阅读:
    魔兽世界祭拜长者
    Mono嵌入C++
    kxb-shell文件操作-kxb
    GAN初步理解
    Pytorch 常用函数方法的理解
    转载:StyleGAN & StyleGAN2 论文解读
    RepVGG
    多目标跟踪,REID, JDE跟踪器解析
    卷积和反卷积详细说明
    FairMOT解析
  • 原文地址:https://www.cnblogs.com/Sunshine-tcf/p/5731087.html
Copyright © 2011-2022 走看看