[hdu 4417 Super Mario] 主席树+离散化 OR 分块

[hdu 4417 Super Mario] 主席树+离散化 OR 分块

题目链接：[hdu 4417 Super Mario]
题意描述：给定$N$个数$a_1,a_2,\ldots,a_n$，$M$次查询，每次查询区间$a_L,a_{L+1},\ldots,a_R$小于$H$数的个数。$(1 \le N，M \le 10^5,0\le a_i,H\le 1000000000）$
解题思路：
方法一： 主席树
首先，原序列长度比较小，数值范围很大，对${a_n}$序列进行离散化，因为后面要用到线段树。
然后就差不多是主席树模板题。第$i$个线段树记录前$i$个数中，离散后的值在区间中出现的个数。每次查询$[L, R] H$的时候，就是第$R$棵线段树的小于等于H的个数减去第$L-1$棵线段树小于等于H的个数。时间复杂度$O(N)$
下面我解释一下为什么一般主席树都是开20倍。主席树的空间复杂度计算：原树需要节点数为$3*N$， 然后需要新增的节点数为$N*log_2N$，因此空间复杂度（总共节点数目）就是$O(3*N+N*log_2N)$， 一般的N 都是$30000\text{~}100000$，对应的$log_2(N)$就是$15\text{~}17$， 所以我们一般都是开$17+3=20$倍大小。
方法二：分块
分块更简单。
将$N$个数字分成$\sqrt{N}$个块。每个块快内进行排序，然后二分区间中每个块，求小于等于的数的个数，再求和。
实现代码：

/**
 * 主席树
 * /
#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

//#pragma comment(linker, "/STACK:1024000000,1024000000")

#define FIN             freopen("input.txt","r",stdin)
#define FOUT            freopen("output.txt","w",stdout)
#define fst             first
#define snd             second
#define __mid__         int mid = ((l + r) >> 1)
#define rep(i, f, t)    for(int i = (f); i <= (t); i++)

typedef __int64 LL;
typedef unsigned __int64 ULL;
typedef pair<int, int> PII;

const int MAXN = 1e5 + 5;
const LL INF = (1 << 60);

int T, N, M, cas;
LL A[MAXN], F[MAXN];
int FSZ, TSZ;

struct TNode {
    int ls, rs, sum;
    TNode() {}
    TNode(int ls, int rs, int sum) : ls(ls), rs(rs), sum(sum) {}
} node[MAXN * 20];
int root[MAXN], RSZ;

int Hash(LL x) {
    return lower_bound(F, F + FSZ, x) - F + 1;
}

int build(int l, int r) {
    int rt = TSZ ++;
    node[rt].sum = 0;
    if(l == r)
        return rt;
    __mid__;
    node[rt].ls = build(l, mid);
    node[rt].rs = build(mid + 1, r);
    return rt;
}

int update(int pos, int prt, int l, int r) {
    int rt = TSZ ++;
    node[rt] = TNode(node[prt].ls, node[prt].rs, node[prt].sum + 1);
    if(l == r) return rt;
    __mid__;
    if(pos <= mid) node[rt].ls = update(pos, node[prt].ls, l, mid);
    else node[rt].rs = update(pos, node[prt].rs, mid + 1, r);
    return rt;
}

int query(int r1, int r2, int pos, int l, int r) {
    int ret = 0;
    if(l == r) return node[r2].sum - node[r1].sum;
    __mid__;
    if(pos <= mid) {
        ret += query(node[r1].ls, node[r2].ls, pos, l, mid);
    } else {
        ret += node[node[r2].ls].sum - node[node[r1].ls].sum;
        ret += query(node[r1].rs, node[r2].rs, pos, mid + 1, r);
    }
    return ret;
}

int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    cas = 0;
    scanf("%d", &T);
    while(T --) {
        scanf("%d %d", &N, &M);
        for(int i = 0; i < N; i++) {
            scanf("%I64d", &A[i]);
            F[i] = A[i];
        }
        RSZ = TSZ = 0;
        sort(F, F + N);
        FSZ = unique(F, F + N) - F;
        F[FSZ ++] = INF;
        root[RSZ ++] = build(1, FSZ);   ///
        for(int i = 0; i < N; i++) {
            int x = Hash(A[i]);
            root[i + 1] = update(x, root[i], 1, FSZ);      ///
        }
        int L, R;
        LL H;
        printf("Case %d:\n", ++ cas);
        while(M --) {
            scanf("%d %d %I64d", &L, &R, &H);
            /// int x = Hash(H);
            int x = upper_bound(F, F + FSZ, H) - F;
            L ++, R ++;
            int ans = 0;
            if(x > 0)
                ans = query(root[L - 1], root[R], x, 1, FSZ);       ///
            printf("%d\n", ans);
        }
    }
    return 0;
}

/**
 * 分块
 * /
#include <bits/stdc++.h>
using namespace std;

typedef __int64 LL;
typedef pair<int, int> PII;

const int MAXN = 1e5 + 5;

int N, M;
int A[MAXN], B[MAXN];
int block, num, F[MAXN];
int L[MAXN], R[MAXN];

int calc(int a, int b, int val) {
    int ret = 0;
    if(F[a] == F[b]) {
        for(int i = a; i <= b; i++) {
            if(A[i] <= val) ret ++;
        }
        return ret;
    }
    int lb, ub;
    if(a % num == 1) lb = L[F[a]];
    else lb = L[F[a] + 1];
    if(b % num == 0) ub = R[F[b]];
    else ub = R[F[b] - 1];
    for(int i = a; i < lb; i++) {
        if(A[i] <= val) ret ++;
    }
    for(int i = lb; i < ub; i += num) {
        int x = upper_bound(B + L[F[i]], B + R[F[i]] + 1, val) - (B + L[F[i]]);
        ret += x;
    }
    for(int i = ub + 1; i <= b; i++) {
        if(A[i] <= val) ret ++;
    }
    return ret;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int _, cas = 0;
    scanf("%d", &_);
    while(_ --) {
        scanf("%d %d", &N, &M);
        num = sqrt(N) + 1; block = N / num + 1;
        for(int i = 1; i <= N; i++) {
            scanf("%d", &A[i]);
            B[i] = A[i];
            F[i] = (i - 1) / num + 1;
        }
        for(int k = 1; k <= block; k++) {
            L[k] = (k - 1) * num + 1;
            R[k] = min(k * num, N);
            sort(B + L[k], B + R[k] + 1);
        }
        printf("Case %d:\n", ++ cas);
        while(M --) {
            int a, b, k; scanf("%d %d %d", &a, &b, &k); a ++, b ++;
            int ret = calc(a, b, k);
            printf("%d\n", ret);
        }
    }
    return 0;
}