[hdu 4417]树状数组+离散化+离线处理

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4417

把数字离散化,一个查询拆成两个查询,每次查询一个前缀的和。主要问题是这个数组是静态的,如果带修改操作就不能离线了。

//http://acm.hdu.edu.cn/showproblem.php?pid=4417
#include<bits/stdc++.h>
using namespace std;

const int maxn=100005;
int tree[maxn];
int N;

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

void init(int n)
{
    N=n;
    for (int i=1;i<=n;i++) tree[i]=0;
}

void add(int k,int x)
{
    while (k<=N)
    {
        tree[k]+=x;
        k+=lowbit(k);
    }
}

int sum(int k)
{
    int res=0;
    while (k)
    {
        res+=tree[k];
        k-=lowbit(k);
    }
    return res;
}

vector<int> ls;
int a[maxn];

struct Query
{
    int id;
    int sgn;
    int p,j;
    int res;
    bool operator < (const Query & q) const
    {
        return p<q.p;
    }
}query[maxn*2];

int ans[maxn];

int main()
{
    int t;
    scanf("%d",&t);
    for (int cas=1;cas<=t;cas++)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
        ls.clear();
        for (int i=1;i<=n;i++) ls.push_back(a[i]);
        sort(ls.begin(),ls.end());
        ls.erase(unique(ls.begin(),ls.end()),ls.end());
        for (int i=0;i<m;i++)
        {
            int l,r,h;
            scanf("%d%d%d",&l,&r,&h);
            l++;
            r++;
            int j=upper_bound(ls.begin(),ls.end(),h)-ls.begin();
            query[i*2].id=i;
            query[i*2].p=l-1;
            query[i*2].j=j;
            query[i*2].sgn=-1;
            query[i*2+1].id=i;
            query[i*2+1].p=r;
            query[i*2+1].j=j;
            query[i*2+1].sgn=1;
        }
        sort(query,query+m*2);
        init(ls.size());
        int now=0;
        for (int i=0;i<=n;i++)
        {
            if (i)
            {
                int j=lower_bound(ls.begin(),ls.end(),a[i])-ls.begin()+1;
                add(j,1);
            }
            while (now<m*2 && query[now].p==i)
            {
                query[now].res=sum(query[now].j);
                now++;
            }
        }
        memset(ans,0,sizeof(ans));
        for (int i=0;i<m*2;i++) ans[query[i].id]+=query[i].res*query[i].sgn;
        printf("Case %d:\n",cas);
        for (int i=0;i<m;i++) printf("%d\n",ans[i]);
    }
    return 0;
}
时间: 2024-11-12 16:59:18

[hdu 4417]树状数组+离散化+离线处理的相关文章

HDU 1394 树状数组+离散化求逆序数

对于求逆序数问题,学会去利用树状数组进行转换求解方式,是很必要的. 一般来说我们求解逆序数,是在给定一串序列里,用循环的方式找到每一个数之前有多少个比它大的数,算法的时间复杂度为o(n2). 那么我们通过树状数组可以明显提高时间效率. 我们可以按照排列的顺序依次将数字放入树状数组中,并依次更新预与之相关联的树状数组元素.那么在将其更新完毕后,我们知道每个数对应的树状数组元素的左边的数肯定比它小,我们在以序列顺序依次更新树状数组时,如果有值在它前面出现,那么它对应的树状数组元素(在这个题目里存放的

hdu 5792 树状数组+离散化+思维

题目大意: 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>Ada≠b≠c≠d,1≤a<b≤n,1≤c<d≤n,Aa<Ab,Ac>Ad. A1,A2?AnA1,A2?An.  1≤n≤500001≤n≤50000  0≤Ai≤1e9 基本思路: 最朴素的思想就是算出所有顺序对所有逆序对

Segment Game (hdu 5372 树状数组+离散化)

Segment Game Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 534    Accepted Submission(s): 132 Problem Description Lillian is a clever girl so that she has lots of fans and often receives gift

hdu 3333(树状数组 + 离散化 + hash)

Turing Tree Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 3847    Accepted Submission(s): 1306 Problem Description After inventing Turing Tree, 3xian always felt boring when solving problems a

hdu 3015 树状数组+离散化

#include <stdio.h> #include <stdlib.h> #include <algorithm> using namespace std; struct data { __int64 order; __int64 orign; __int64 rank; }; data heigh[100100], coor[100100]; int cmp(const void *a, const void *b) { return ( (*(data *)a)

Turing Tree HDU - 3333 (树状数组,离线求区间元素种类数)

After inventing Turing Tree, 3xian always felt boring when solving problems about intervals, because Turing Tree could easily have the solution. As well, wily 3xian made lots of new problems about intervals. So, today, this sick thing happens again..

Swaps and Inversions HDU - 6318 树状数组+离散化

#include<iostream> #include<algorithm> #include<cstring> #include<cstdio> using namespace std; typedef long long ll; const int N=1e5+10; int a[N]; int ra[N]; int tr[N]; int n,x,y; int sz; int lowbit(int x) { return x&-x; } void

C - The Battle of Chibi HDU - 5542 (树状数组+离散化)

Cao Cao made up a big army and was going to invade the whole South China. Yu Zhou was worried about it. He thought the only way to beat Cao Cao is to have a spy in Cao Cao's army. But all generals and soldiers of Cao Cao were loyal, it's impossible t

hdu4325 树状数组+离散化

http://acm.hdu.edu.cn/showproblem.php?pid=4325 Problem Description As is known to all, the blooming time and duration varies between different kinds of flowers. Now there is a garden planted full of flowers. The gardener wants to know how many flower