[洛谷P3765]总统选举

这道题要明白摩尔投票法，详见[洛谷P2397]yyy loves Maths VI (mode)。

还有一个就是可加性。

所以我们可以用线段树维护区间过半数。

但是不一定就过了半，所以再往平衡树里面查下。

平衡树要开很多棵，对应的平衡树中存放对应数的位置。

然后查询某个数在区间$[l,r]$中出现次数，就是查找对应平衡树中$l$和$r$的排名的差值$+1$。

然后就解决了。

另外这里尝试了指针版线段树，发现不习惯。下次还是要用数组。

#include <bits/stdc++.h>

using namespace std;

#define re register
#define rep(i, a, b) for (re int i = a; i <= b; ++i)
#define repd(i, a, b) for (re int i = a; i >= b; --i)
#define maxx(a, b) a = max(a, b);
#define minn(a, b) a = min(a, b);
#define LL long long
#define INF (1 << 30)

inline int read() {
    int w = 0, f = 1; char c = getchar();
    while (!isdigit(c)) f = c == '-' ? -1 : f, c = getchar();
    while (isdigit(c)) w = (w << 3) + (w << 1) + (c ^ '0'), c = getchar();
    return w * f;
}

const int maxn = 5e5 + 5;

int a[maxn];

struct segN {
    segN *ch[2];
    int num, cnt;
    void maintain() {
        if (ch[0]->num == ch[1]->num) { num = ch[0]->num, cnt = ch[0]->cnt + ch[1]->cnt; }
        else if (ch[0]->cnt >= ch[1]->cnt) { num = ch[0]->num, cnt = ch[0]->cnt - ch[1]->cnt; }
        else num = ch[1]->num, cnt = ch[1]->cnt - ch[0]->cnt;
    }
} *seg_null, *seg_root;

void seg_build(segN* &o, int l, int r) {
    o = new segN();
    if (l == r) { o->num = a[l], o->cnt = 1; return; }
    int mid = (l + r) >> 1;
    seg_build(o->ch[0], l, mid);
    seg_build(o->ch[1], mid+1, r);
    o->maintain();
}

void seg_update(segN* o, int l, int r, int p, int x) {
    if (l == r) { o->num = x; return; }
    int mid = (l + r) >> 1;
    if (p <= mid) seg_update(o->ch[0], l, mid, p, x);
    else seg_update(o->ch[1], mid+1, r, p, x);
    o->maintain();
}

int seg_query(segN* o, int l, int r, int ql, int qr, int &cnt) {
    if (ql <= l && r <= qr) { cnt = o->cnt; return o->num; }
    int mid = (l + r) >> 1, lnum = -1, lcnt = 0, rnum = -1, rcnt = 0;
    if (ql <= mid) lnum = seg_query(o->ch[0], l, mid, ql, qr, lcnt);
    if (mid < qr) rnum = seg_query(o->ch[1], mid+1, r, ql, qr, rcnt);
    if (lnum == rnum) { cnt = lcnt+rcnt; return lnum; }
    if (lcnt >= rcnt && lnum != -1) { cnt = lcnt-rcnt; return lnum; }
    cnt = rcnt-lcnt; return rnum;
}

struct bstN {
    bstN *ch[2];
    int v, r, s;
    bstN(int v, bstN* son) : v(v) { ch[0] = ch[1] = son; r = rand(); s = 1; }
    void maintain() { s = ch[0]->s + ch[1]->s + 1; }
} *bst_null, *bst_root[maxn];

bstN* merge(bstN *a, bstN *b) {
    if (a == bst_null) return b;
    if (b == bst_null) return a;
    if (a->r > b->r) { a->ch[1] = merge(a->ch[1], b); a->maintain(); return a; }
    b->ch[0] = merge(a, b->ch[0]); b->maintain(); return b;
}

void split(bstN* o, int v, bstN* &l, bstN* &r) {
    if (o == bst_null) { l = r = bst_null; return; }
    if (o->v <= v) { l = o; split(o->ch[1], v, l->ch[1], r); }
    else { r = o; split(o->ch[0], v, l, r->ch[0]); }
    o->maintain();
}

void insert(bstN* &root, int v) {
    bstN *l, *r;
    split(root, v, l, r);
    root = merge(merge(l, new bstN(v, bst_null)), r);
}

void remove(bstN* &root, int v) {
    bstN *l, *mid, *r;
    split(root, v-1, l, r);
    split(r, v, mid, r);
    delete(mid);
    root = merge(l, r);
}

int query(bstN* &root, int ql, int qr) {
    bstN *l, *mid, *r;
    split(root, ql-1, l, r);
    split(r, qr, mid, r);
    int res = mid->s;
    root = merge(merge(l, mid), r);
    return res;
}

int n, m;

void initnull() {
    seg_null = new segN(); seg_null->ch[0] = seg_null->ch[1] = seg_null;
    bst_null = new bstN(0, NULL); bst_null->ch[0] = bst_null->ch[1] = bst_null; bst_null->s = 0;
    rep(i, 1, n) bst_root[i] = bst_null;
}

int main() {
    srand(19260817);
    n = read(), m = read();
    initnull();
    rep(i, 1, n) a[i] = read(), insert(bst_root[a[i]], i);
    seg_build(seg_root, 1, n);
    while (m--) {
        int l = read(), r = read(), s = read(), k = read(), cnt, ans = seg_query(seg_root, 1, n, l, r, cnt);
        if (query(bst_root[ans], l, r) <= (r-l+1)/2) ans = s;
        printf("%d
", ans);
        rep(i, 1, k) {
            int v = read();
            remove(bst_root[a[v]], v);
            a[v] = ans;
            insert(bst_root[a[v]], v);
            seg_update(seg_root, 1, n, v, ans);
        }
    }
    if (query(bst_root[seg_root->num], 1, n) > n/2) printf("%d", seg_root->num);
    else printf("-1");
    return 0;
}