題目

題解

比較經典的題目，我用了三個方法來寫。

其中第一種第三種我覺得比較好寫，第二種出現了各種問題。

總的來說第一種速度快，但是程式碼長，第三種速度慢一些，但是程式碼比較短，第二種程式碼和第三種差不多，但是慢了很多，寫起來很蛋疼。

第一種是我自己寫的寫法，後兩種是書上的寫法。好像還可以用其他亂七八糟樹來弄。

題解1

首先可以離散化一下資料。

然後莫隊去搞，然後用樹狀陣列來維護整個個數，再去二分答案。

整個程式碼比較長，不過寫起來還是比較方便的。

莫隊+樹狀陣列程式碼

#include <iostream>
 

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>
#define fi first
#define se second
using namespace std;
typedef long
 
 long LL;
typedef pair<int,int> PII;
// head
const int N = 1e5+5;
const int M = 5e3+5;
const int B = 1000;

struct BIT {
#define T int
    T tree[N] ;
    inline int lowbit(int x) {
        return x&(-x);
    }
    void add(int x, T add, int n) {
        for (int i = x; i <= n; i += lowbit(i)) {
            tree[i] += add;
        }
    }
    T sum(int
 
 x) {
        T ans = 0;
        for (int i = x; i > 0; i -= lowbit(i)) {
            ans += tree[i];
        }
        return ans;
    }
    T query(int k, int n) {
        int l = 1, r = n, ans = n;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (sum(mid) >= k) {
                ans = mid;
                r = mid-1;
            } else {
                l = mid+1;
            }
        }
        return ans;
    }
    void clear(int n) {
        for (int i = 1; i <= n; i++) {
            tree[i] = 0;
        }
    }
#undef T
};

BIT bt;

struct Query {
    int l, r, k, id;
};

bool cmp(const Query &a, const Query &b) {
    int apos = a.l / B, bpos = b.l / B;
    return apos == bpos ? a.r < b.r : apos < bpos;
}

Query query[M];
int a[N];
int dis[N];
int res[M];

void add(int x, int n) {
    bt.add(x, 1, n);
}
void rem(int x, int n) {
    bt.add(x, -1, n);
}
int main() {
    int n, m;
    while (scanf("%d%d", &n, &m) == 2) {
        for (int i = 1; i <= n; i++) {
            scanf("%d", a+i);
            dis[i-1] = a[i];
        }
        sort(dis, dis + n);
        int tot = unique(dis, dis + n) - dis;
        for (int i = 1; i <= n; i++) {
            a[i] = lower_bound(dis, dis + tot, a[i]) - dis + 1;
        }

        for (int i = 0; i < m; i++) {
            scanf("%d%d%d", &query[i].l, &query[i].r, &query[i].k);
            query[i].id = i;
        }
        sort(query, query + m, cmp);

        int l = 1, r = 0;
        for (int i = 0; i < m; i++) {
            while (r < query[i].r) add(a[++r], tot);
            while (l > query[i].l) add(a[--l], tot);
            while (r > query[i].r) rem(a[r--], tot);
            while (l < query[i].l) rem(a[l++], tot);
            res[query[i].id] = bt.query(query[i].k, tot);
        }

        for (int i = 0; i < m; i++) {
            printf("%d\n", dis[res[i]-1]);
        }
        bt.clear(tot);
    }
    return 0;
}

題解2

然後我們也可以把整個東西劃分成約n−−√個塊，每塊內排序。

對於完整在裡面的一塊，可以二分，兩邊的則直接暴力for。

需要注意的是右邊的區間應該繼續往下減而不是停留在模B為0。

否則最後一塊的第一個元素會漏處理，可以處理成左閉右開。

平方分解程式碼

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
// head
const int N = 1e5+5;
const int B = 1000;

vector<int> b[N/B + 5];
int a[N], c[N];

int get(int l, int r, int x) {
    int ans = 0;
    while (l < r && l % B) {
        if (a[l++] <= x) ans++;
    }
    while (l < r && r % B) {
        if (a[--r] <= x) ans++;
    }
    for (int i = l; i < r; i += B) {
        int pos = i / B;
        ans += upper_bound(b[pos].begin(), b[pos].end(), x) - b[pos].begin();
    }
    return ans;
}

int query(int L, int R, int k, int n) {
    int l = 0, r = n-1, ans;
    while (l <= r) {
        int mid = (l + r) / 2;
        int cur = get(L, R, c[mid]);
        if (cur >= k) {
            ans = mid;
            r = mid-1;
        } else {
            l = mid+1;
        }
    }
    return c[ans];
}

int main() {
    int n, m, x, l, r, k;
    while (scanf("%d%d", &n, &m) == 2) {
        for (int i = 0; i < n; i++) {
            scanf("%d", a+i);
            c[i] = a[i];
            b[i/B].push_back(a[i]);
        }
        sort(c, c + n);
        for (int i = 0; i <= n/B; i++) {
            sort(b[i].begin(), b[i].end());
        }

        for (int i = 0; i < m; i++) {
            scanf("%d%d%d", &l, &r, &k);
            l--;
            printf("%d\n", query(l, r, k, n));
        }

        for (int i = 0; i <= n/B; i++) {
            b[i].clear();
        }
    }
    return 0;
}

題解3

然後可以建一顆歸併樹，在樹上找到區間然後去二分。

具體就是每個節點儲存一個升序的陣列，然後不斷merge。

線段樹程式碼

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
// head
const int N = 1e5+5;

int a[N];
struct SegmentTree {
#define lson (rt<<1)
#define rson ((rt<<1)|1)
#define MID ((L+R)>>1)
#define lsonPara lson, L, MID
#define rsonPara rson, MID+1, R
#define all(v) v.begin(), v.end()

    const static int TN = N << 2;

    vector<int> t[TN];

    void pushUp(int rt, int L, int R) {
        t[rt].resize(R - L + 1);
        merge(all(t[lson]), all(t[rson]), t[rt].begin());
    }

    void build(int rt, int L, int R) {
        if (L == R) {
            t[rt].resize(1);
            scanf("%d", a+L);
            t[rt][0] = a[L];
        } else {
            build(lsonPara);
            build(rsonPara);
            pushUp(rt, L, R);
        }
    }

    int query(int rt, int L, int R, int l, int r, int x) {
        if (l > R || r < L || l > r) return 0;
        if (l <= L && r >= R) {
            int ans = upper_bound(all(t[rt]), x) - t[rt].begin();
            return ans;
        }
        return query(lsonPara, l, r, x) + query(rsonPara, l, r, x);
    }
};

SegmentTree st;
int main() {
    int n, m, L, R, k;
    while (scanf("%d%d", &n, &m) == 2) {
        st.build(1, 1, n);
        sort(a + 1, a + n + 1);
        int tot = unique(a + 1, a + n + 1) - a;
        while (m--) {
            scanf("%d%d%d", &L, &R, &k);
            int l = 1, r = tot-1, ans;
            while (l <= r) {
                int mid = (l + r) / 2;
                if (st.query(1, 1, n, L, R, a[mid]) >= k) {
                    ans = mid;
                    r = mid-1;
                } else {
                    l = mid+1;
                }
            }
            printf("%d\n", a[ans]);
        }
    }
    return 0;
}