洛谷 2056 采花 - 可持久化线段树 - 树状数组

莫队做法请参见原来的博客 [传送门]

Solution II (主席树,在线)

　　考虑直接利用主席树统计每个位置对答案的贡献。

　　查询[l, r]就是在第r棵线段树内查询[l, r]

　　对于建树，考虑到位置i，和位置(i - 1)的不同在于，位置i可能会导致之前的某个位置对答案的贡献从1变为0，或者某个位置的贡献从0变为1.

　　至于什么什么情况产生贡献？考虑在[1, r]中，从r向1计数，某个数第二出现的位置就对答案有1的贡献。

　　然后建树的过程就很显然了。

Code

/**
 * luogu
 * Problem#2056
 * Accepted
 * Time: 736ms
 * Memory: 88007k
 */ 
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
typedef pair<int, int> pii;
#define fi first
#define sc second

typedef class SegTreeNode {
    public:
        int val;
        SegTreeNode *l;
        SegTreeNode *r;
        int belong;
        
        SegTreeNode(int val = 0):val(val), l(NULL), r(NULL), belong(-1) {        }
        SegTreeNode(int val, SegTreeNode* org):val(val), l(org), r(org), belong(-1) {        }
        
        void pushUp() {
            val = l->val + r->val;
        }
}SegTreeNode;

#define Limit 2000000

SegTreeNode pool[Limit];
SegTreeNode* top = pool;
SegTreeNode null = SegTreeNode(0, &null);

SegTreeNode* newnode() {
    if(top == pool + Limit)
        return new SegTreeNode(0, &null);
    *top = null;
    return top++; 
}

typedef class SegTree {
    public:
        int ver;
        int n;
        SegTreeNode** rt;
        
        SegTree() {    }
        SegTree(int n):ver(0), n(n) {
            rt = new SegTreeNode*[(n + 1)];
            for(int i = 0; i <= n; i++)
                rt[i] = &null;
        }
        
        void update(SegTreeNode*& pOld, SegTreeNode*& pNew, int l, int r, int p, int val) {
            if(pNew->belong != ver + 1)
                pNew = newnode(), *pNew = *pOld, pNew->belong = ver + 1;
            pNew->val += val;
            if(l == r)
                return;
            int mid = (l + r) >> 1;
            if(p <= mid)
                update(pOld->l, pNew->l, l, mid, p, val);
            else
                update(pOld->r, pNew->r, mid + 1, r, p, val);
        }
        
        int query(SegTreeNode*& node, int l, int r, int ql, int qr) {
            if(l == ql && r == qr)
                return node->val;
            int mid = (l + r) >> 1, rt = 0;
            if(ql <= mid)
                rt += query(node->l, l, mid, ql, (qr < mid) ? (qr) : (mid));
            if(qr > mid)
                rt += query(node->r, mid + 1, r, (ql > mid) ? (ql) : (mid + 1), qr);
            return rt;
        }
        
        SegTreeNode*& operator [] (int pos) {
            return rt[pos];
        }
}SegTree;

int n, c, m;
SegTree st;
int *ar;

inline void init() {
    scanf("%d%d%d", &n, &c, &m);
    st = SegTree(n);
    ar = new int[(n + 1)];
    for(int i = 1; i <= n; i++)
        scanf("%d", ar + i);
}

pii *last;
inline void solve() {
    last = new pii[(c + 1)];
    fill(last + 1, last + c + 1, pii(-1, -1));
    for(int i = 1; i <= n; i++) {
        boolean aflag = true;
        if(last[ar[i]].sc != -1)
            st.update(st[i - 1], st[i], 1, n, last[ar[i]].sc, -1), aflag = false;
        last[ar[i]].sc = last[ar[i]].fi;
        last[ar[i]].fi = i;
        if(last[ar[i]].sc != -1)
            st.update(st[i - 1], st[i], 1, n, last[ar[i]].sc, 1), aflag = false;
        if(aflag)
            st[i] = st[i - 1];
        st.ver++;
    }
    
    int l, r;
    while(m--) {
        scanf("%d%d", &l, &r);
        printf("%d\n", st.query(st[r], 1, n, l, r));
    }
}

int main() {
    init();
    solve();
    return 0;
}

Solution III (树状数组,离线)

　　结合一下莫队算法再想想，其实可以读入所有操作，按照右端点排序，在建树的过程中就可以计算答案。

　　因为没必要把之前的树保留，所以直接用树状数组就好了。

Code

/**
 * luogu            & codevs
 * Problem#2056        & 2365
 * Accepted            & Accepted
 * Time: 188ms        & 3500ms
 * Memory: 4457k    & 53772k
 */
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
typedef pair<int, int> pii;
#define fi first
#define sc second

typedef class IndexedTree {
    public:
        int s;
        int* ar;
        
        IndexedTree() {        }
        IndexedTree(int n):s(n) {
            ar = new int[(n + 1)];
            memset(ar, 0, sizeof(int) * (n + 1));
        }
        
        inline void add(int idx, int val) {
            for(; idx <= s; idx += (idx & (-idx)))
                ar[idx] += val;
        }
        
        inline int getSum(int idx) {
            int rt = 0;
            for(; idx; idx -= (idx & (-idx)))
                rt += ar[idx];
            return rt;
        }
}IndexedTree;

typedef class Query {
    public:
        int l, r, id;
        
        Query(int l = 0, int r = 0, int id = 0):l(l), r(r), id(id) {        }
        
        boolean operator < (Query b) const {
            if(r != b.r)    return r < b.r;
            return l < b.l;
        }
}Query;

int n, c, m;
Query *qs;
int* ar;
IndexedTree it;

inline void init() {
    scanf("%d%d%d", &n, &c, &m);
    it = IndexedTree(n);
    qs = new Query[(m + 1)];
    ar = new int[(n + 1)];
    for(int i = 1; i <= n; i++)
        scanf("%d", ar + i);
    for(int i = 1; i <= m; i++)
        scanf("%d%d", &qs[i].l, &qs[i].r), qs[i].id = i;
}

pii *last;
int *res;
inline void solve() {
    last = new pii[(c + 1)];
    res = new int[(m + 1)];
    fill(last + 1, last + c + 1, pii(-1, -1));
    sort(qs + 1, qs + m + 1);
    int p = 1;
    for(int i = 1, e; i <= n && p <= m; i++) {
        e = ar[i];
        if(last[e].sc != -1)
            it.add(last[e].sc, -1);
        last[e].sc = last[e].fi;
        last[e].fi = i;
        if(last[e].sc != -1)
            it.add(last[e].sc, 1);
        while(qs[p].r == i)
            res[qs[p].id] = it.getSum(qs[p].r) - it.getSum(qs[p].l - 1), p++;
    }
    for(int i = 1; i <= m; i++)
        printf("%d\n", res[i]);
}

int main() {
    init();
    solve();
    return 0;
}