求LCA练习+部分算法复习 2017.1.22

---

　　第一题就LCA即可。不过推荐用Tarjan(最快,常数很小)。然后Tarjan的时候顺便就出一个dist[i]，表示i节点到根节点的距离。求出了LCA，那么两点间的距离就为dist[u] + dist[v] - 2 * dist[lca]。

Code

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
#ifndef    WIN32
#define    AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

typedef class Edge {
    public:
        int end;
        int next;
        int w;
        Edge(const int end = 0, const int next = 0, const int w = 0):end(end), next(next), w(w){        }
}Edge;

typedef class MapManager{
    public:
        int ce;
        Edge* edges;
        int* h;
        MapManager():ce(0), edges(NULL), h(NULL){        }
        MapManager(int points, int limit):ce(0){
            edges = new Edge[(const int)(limit + 1)];
            h = new int[(const int)(points + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int w){
            edges[++ce] = Edge(end, h[from], w);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int w){
            addEdge(from, end, w);
            addEdge(end, from, w);
        }
        Edge& operator [](int pos){
            return edges[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]

typedef class union_found{
    public:
        int *f;
        union_found():f(NULL) {}
        union_found(int points) {
            f = new int[(const int)(points + 1)];
        }
        int find(int x) {
            if(f[x] != x)    return f[x] = find(f[x]);
            return f[x];
        }
        void unit(int fa, int so) {
            int ffa = find(fa);
            int fso = find(so);
            f[fso] = ffa;
        }
        int& operator [](int pos){
            return f[pos];
        }
}union_found;

int n, m;
MapManager g;
MapManager q;
int *results;
boolean* enable;
int *querya, *queryb;
union_found uf;
boolean* visited;
int* dist;

inline void init(){
    readInteger(n);
    g = MapManager(n, 2 * n);
    for(int i = 1, a, b, c; i < n; i++){
        readInteger(a);
        readInteger(b);
        readInteger(c);
        g.addDoubleEdge(a, b, c);
    }
    readInteger(m);
    q = MapManager(n, 2 * m);
    querya = new int[(const int)(m + 1)];
    queryb = new int[(const int)(m + 1)];
    results = new int[(const int)(m + 1)];
    enable = new boolean[(const int)(m + 1)];
    dist = new int[(const int)(n + 1)];
    uf = union_found(n);
    visited = new boolean[(const int)(n + 1)];
    memset(visited, false, sizeof(boolean) * (n + 1));
    memset(enable, true, sizeof(boolean) * (m + 1));
    for(int i = 1; i <= m; i++){
        readInteger(querya[i]);
        readInteger(queryb[i]);
        q.addDoubleEdge(querya[i], queryb[i], i);
    }
    dist[1] = 0;
}

void tarjan(int node, int f){
    uf[node] = node;
    visited[node] = true;
    for(int i = m_begin(g, node); i != 0; i = g[i].next){
        int& e = g[i].end;
        if(e == f)    continue;
        dist[e] = dist[node] + g[i].w;
        tarjan(e, node);
        uf[e] = node;
    }
    for(int i = m_begin(q, node); i != 0; i = q[i].next) {
        int& e = q[i].end;
        if(visited[e] && enable[q[i].w]){
            int lca = uf.find(e);
            results[q[i].w] = lca;
            enable[q[i].w] = false;
        }
    }
}

inline void solve(){
    tarjan(1, 0);
    for(int i = 1; i <= m; i++){
        int dis = dist[querya[i]] + dist[queryb[i]] - 2 * dist[results[i]];
        printf("%d
", dis);
    }
}

int main(){
    freopen("distance.in", "r", stdin);
    freopen("distance.out", "w", stdout);
    init();
    solve();
    return 0;
}

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
#ifndef    WIN32
#define    AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

template<typename T>class Matrix{
    public:
        T *p;
        int lines;
        int rows;
        Matrix():p(NULL){    }
        Matrix(int rows, int lines):lines(lines), rows(rows){
            p = new T[(lines * rows)];
        }
        T* operator [](int pos){
            return (p + pos * lines);
        }
};
#define matset(m, i, s) memset((m).p, (i), (s) * (m).lines * (m).rows)

///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        int w;
        Edge(const int end = 0, const int next = 0, const int w = 0):end(end), next(next), w(w){}
}Edge;
typedef class MapManager{
    public:
        int ce;
        int *h;
        int w;
        Edge *edge;
        MapManager(){}
        MapManager(int points, int limit):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int w){
            edge[++ce] = Edge(end, h[from], w);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int w){
            addEdge(from, end, w);
            addEdge(end, from, w);
        }
        Edge& operator[] (int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
///map template ends

int n, m;
int cnt = 0;
Matrix<int> st;
int* seq;
int* dep;
int *app;
MapManager g;
int *mlog2;
long long *dist;

inline void init() {
    readInteger(n);
    g = MapManager(n, 2  * n);
    seq = new int[(const int)(2 * n + 1)];
    dist = new long long[(const int)(n + 1)];
    dep = new int[(const int)(n + 1)];
    app = new int[(const int)(n + 1)];
    for(int i = 1, a, b, w; i < n; i++){
        readInteger(a);
        readInteger(b);
        readInteger(w);
        g.addDoubleEdge(a, b, w);
    }
    dist[1] = 0;
    dep[0] = 0;
}

void dfs(int node, int f) {
    seq[++cnt] = node;
    app[node] = cnt;
    dep[node] = dep[f] + 1;
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(e == f)    continue;
        dist[e] = dist[node] + g[i].w;
        dfs(e, node);
        seq[++cnt] = node;
    }
}

inline void init_log() {
    mlog2 = new int[(const int)(2 * n + 1)];
    mlog2[1] = 0;
    for(int i = 2; i <= 2 * n; i++)
        mlog2[i] = mlog2[i / 2] + 1; 
}

inline void init_st() {
    init_log();
    st = Matrix<int>(cnt, mlog2[cnt] + 1);
    for(int i = 1; i <= cnt; i++)
        st[i][0] = seq[i];
    for(int j = 1; j <= mlog2[cnt]; j++)
        for(int i = 1; i + (1 << j) - 1 <= cnt; i++)
            st[i][j] = (dep[st[i][j - 1]] < dep[st[i + (1 << (j - 1))][j - 1]]) ? (st[i][j - 1]) : (st[i + (1 << (j - 1))][j - 1]);
}

inline int lca(int a, int b) {
    if(app[a] > app[b])    swap(a, b);
    int pos = mlog2[app[b] - app[a] + 1];
    int u = st[app[a]][pos];
    int v = st[app[b] - (1 << pos) + 1][pos];
    return (dep[u] > dep[v]) ? (v) : (u);
}

long long dis;
inline void solve() {
    readInteger(m);
    for(int i = 1, a, b; i <= m; i++){
        readInteger(a);
        readInteger(b);
        int l = lca(a, b);
        dis = dist[a] + dist[b] - 2 * dist[l];
        printf(AUTO"
", dis);
    }
}

int main() {
    freopen("distance.in", "r", stdin);
    freopen("distance.out", "w", stdout);
    init();
    dfs(1, 0);
    init_st();
    solve();
    return 0;
}

　　话说ST表在n，q都尽量大的情况下，其他数据随机，竟然平均一个点比Tarjan 0.05s左右。（也有可能是我的st表写得比较丑）

---

---

　　第二题还是一遍dfs序，接着可以开开心心地放线段树去装逼了。(然而我把某些"+="写成了"="，于是AK又没有了。。一定是写这道题和检查的时候头脑都不清醒)

Code

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
#ifdef    WIN32
#define    AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

typedef class Edge {
    public:
        int end;
        int next;
        Edge(const int end = 0, const int next = 0):end(end), next(next){        }
}Edge;

typedef class MapManager{
    public:
        int ce;
        Edge* edges;
        int* h;
        MapManager():ce(0), edges(NULL), h(NULL){        }
        MapManager(int points, int limit):ce(0){
            edges = new Edge[(const int)(limit + 1)];
            h = new int[(const int)(points + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end){
            edges[++ce] = Edge(end, h[from]);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end){
            addEdge(from, end);
            addEdge(end, from);
        }
        Edge& operator [](int pos){
            return edges[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]

typedef class SegTreeNode{
    public:
        long long sum;
        int l, r;
        SegTreeNode *left, *right;
        long long lazy;
        SegTreeNode(int l, int r):l(l), r(r), sum(0), lazy(0), left(NULL), right(NULL){        }
        
        inline void pushUp(){
            this->sum = left->sum + right->sum;
        }
        
        inline void pushDown(){
            left->lazy += lazy;
            right->lazy += lazy;
            left->sum += lazy * (left->r - left->l + 1);
            right->sum += lazy * (right->r - right->l + 1);
            lazy = 0;
        }
}SegTreeNode;

typedef class SegTree {
    public:
        SegTreeNode* root;
        SegTree():root(NULL){    }
        SegTree(int size) {
            build(root, 1, size);
        }
        
        void build(SegTreeNode*& node, int l, int r){
            node = new SegTreeNode(l, r);
            if(l == r)    return;
            int mid = (l + r) >> 1;
            build(node->left, l, mid);
            build(node->right, mid + 1, r);
        }
        
        void update(SegTreeNode*& node, int l, int r, int from, int end, long long val){
            if(l == from && r == end){
                node->sum += val * (r - l + 1);
                node->lazy += val;
                return;
            }
            if(node->lazy)    node->pushDown();
            int mid = (l + r) >> 1;
            if(end <= mid)    update(node->left, l, mid, from, end, val);
            else if(from > mid)    update(node->right, mid + 1, r, from, end, val);
            else{
                update(node->left, l, mid, from, mid, val);
                update(node->right, mid + 1, r, mid + 1, end, val);
            }
            node->pushUp();
        }
        
        long long query(SegTreeNode*& node, int index){
            if(node->l == index && node->r == index){
                return node->sum;
            }
            if(node->lazy)    node->pushDown();
            int mid = (node->l + node->r) >> 1;
            if(index <= mid)    return query(node->left, index);
            return query(node->right, index);
        }
        
        long long query(SegTreeNode*& node, int from, int end){
            if(node->l == from && node->r == end){
                return node->sum;
            }
            if(node->lazy)    node->pushDown();
            int mid = (node->l + node->r) >> 1;
            if(end <= mid)    return query(node->left, from, end);
            if(from > mid)    return query(node->right, from, end);
            return query(node->left, from, mid) + query(node->right, mid + 1, end);
        }
}SegTree;

int n, m;
SegTree st;
int cnt = 0;
int* visitID;
int* exitID;
MapManager g;

inline void init() {
    readInteger(n);
    g = MapManager(n, 2 * n);
    for(int i = 1, a, b; i < n; i++){
        readInteger(a);
        readInteger(b);
        g.addDoubleEdge(a, b);
    }
    visitID = new int[(const int)(n + 1)];
    exitID = new int[(const int)(n + 1)];
}

void dfs(int node, int last){
    visitID[node] = ++cnt;
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(e == last)    continue;
        dfs(e, node);
    }
    exitID[node] = cnt;
}

inline void solve() {
    dfs(1, 0);
    readInteger(m);
    st = SegTree(n);
    char cmd[10];
    int a, b;
    while(m--) {
        scanf("%s", cmd);
        readInteger(a);
        if(cmd[0] == 'g') {
            readInteger(b);
            st.update(st.root, 1, n, visitID[a], exitID[a], b);
        }else if(cmd[0] == 's'){
            long long res = st.query(st.root, visitID[a]);
            printf(AUTO"
", res);
        }else if(cmd[0] == 'a'){
            long long res = st.query(st.root, visitID[a], exitID[a]);
            printf(AUTO"
", res);
        }
    }
}

int main() {
    freopen("redpacket.in", "r", stdin);
    freopen("redpacket.out", "w", stdout);
    init();
    solve();
    return 0;
}

---

---

---

　　一看就发现是专为值域线段树设置的裸题。

Code

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
#ifndef    WIN32
#define    AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

typedef class SegTreeNode {
    public:
        int s;
        SegTreeNode* left, *right;
        
        inline void pushUp(){
            s = left->s + right->s;
        }
}SegTreeNode;

typedef class SegTree {
    public:
        int lb, rb;
        SegTreeNode* root;
        SegTree():root(NULL) {        }
        SegTree(int lb, int rb, int* list):lb(lb), rb(rb){
            build(root, 1, rb - lb + 1, list);
        }
        
        void build(SegTreeNode*& node, int l, int r, int* list){
            node = new SegTreeNode();
            if(l == r){
                node->s = list[l];
                return;
            }
            int mid = (l + r) >> 1;
            build(node->left, l, mid, list);
            build(node->right, mid + 1, r, list);
            node->pushUp();
        }
        
        void update(SegTreeNode*& node, int l, int r, int index, int val){
            if(l == index && r == index){
                node->s += val;
                smax(node->s, 0);
                return;
            }
            int mid = (l + r) >> 1;
            if(index <= mid)    update(node->left, l, mid, index, val);
            else update(node->right, mid + 1, r, index, val);
            node->pushUp();
        }
        
        int findKth(SegTreeNode*& node, int l, int r, int k){
            if(l == r)    return l + lb - 1;
            int ls = node->left->s;
            int mid = (l + r) >> 1;
            if(k <= ls)    return findKth(node->left, l, mid, k);            
            return findKth(node->right, mid + 1, r, k - ls);
        }
}SegTree;

int n;
int lb, rb;
int* list;
SegTree st;
inline void init() {
    readInteger(lb);
    readInteger(rb);
    list = new int[(const int)(rb - lb + 2)];
    for(int i = lb; i <= rb; i++){
        readInteger(list[i - lb + 1]);
    }
    st = SegTree(lb, rb, list);
}

inline void solve() {
    const int L = rb - lb + 1;
    readInteger(n);
    char cmd[10];
    int a;
    while(n--) {
        scanf("%s", cmd);
        readInteger(a);
        if(cmd[0] == 'a'){
            st.update(st.root, 1, L, a - lb + 1, 1);
        }else if(cmd[0] == 'd'){
            st.update(st.root, 1, L, a - lb + 1, -1);
        }else{
            int res = st.findKth(st.root, 1, L, a);
            printf("%d
", res);
        }
    }
}

int main(){
    freopen("kth.in", "r", stdin);
    freopen("kth.out", "w", stdout);
    init();
    solve();
    return 0;
}

　　然后我还用了替罪羊树(然而发现，都快成普通的二叉搜索树了)，O(n)离线建完整棵树，插入删除都不需要重构，即使为count为0也不管(删掉它需要花费更过的时间)。不过测了后发现，略微比值域线段树快一点，应该是因为各种操作在中途完成就开始返回了。

Code

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
#ifndef    WIN32
#define    AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

template<typename T>
class ScapegoatTreeNode {
    public:
        T val;
        int count;
        int size;
        ScapegoatTreeNode* next[2];
        ScapegoatTreeNode():count(1), size(1){
            memset(next, 0, sizeof(next));
        }
        ScapegoatTreeNode(T val):val(val), count(1), size(1){
            memset(next, 0, sizeof(next));
        }
        
        inline void maintain() {
            size = count;
            for(int i = 0; i < 2; i++)
                if(next[i] != NULL)
                    size += next[i]->size;
        }
        
        inline void addCount(int c){
            if(count == 0 && c < 0)    return;
            size += c, count += c;
        }
        
        inline int cmp(T x){
            if(val == x)    return -1;
            return (x < val) ? (0) : (1);
        }
};

template<typename T>
class ScapegoatTree {
    protected:
        static void insert(ScapegoatTreeNode<T>*& node, T val){
            if(node == NULL){
                node = new ScapegoatTreeNode<T>(val);
                return;
            }
            int d = node->cmp(val);
            if(d == -1){
                node->addCount(1);
                return;
            }
            insert(node->next[d], val);
            node->maintain();
        }
        
        static boolean remove(ScapegoatTreeNode<T>*& node, T val){
            if(node == NULL)    return false;
            int d = node->cmp(val);
            if(d == -1){
                node->addCount(-1);
                return true;
            }
            boolean res = remove(node->next[d], val);
            if(res)    node->maintain();
            return res;
        }
        
        static ScapegoatTreeNode<T>* findKth(ScapegoatTreeNode<T>*& node, int k){
            int ls = (node->next[0] == NULL) ? (0) : (node->next[0]->size);
            if(k >= ls + 1 && k <= ls + node->count)    return node;
            if(k <= ls)    return findKth(node->next[0], k);
            return findKth(node->next[1], k - ls - node->count);
        }
    public:
        ScapegoatTreeNode<T>* root;
        vector<ScapegoatTreeNode<T>*> lis;
        
        ScapegoatTree():root(NULL){        }
        
        ScapegoatTreeNode<T>* rebuild(int l, int r){
            if(l > r)    return NULL;
            int mid = (l + r) >> 1;
            ScapegoatTreeNode<T>*& node = lis[mid];
            node->next[0] = rebuild(l, mid - 1);
            node->next[1] = rebuild(mid + 1, r);
            node->maintain();
            return node;
        }
        
        void rebuild(ScapegoatTreeNode<T>*& node, ScapegoatTreeNode<T>*& f){
            lis.clear();
            travel(node);
            int d = -1;
            if(f != NULL)    d = f->cmp(node->val);
            ScapegoatTreeNode<T>* res = rebuild(0, lis.size() - 1);
            if(d != -1)        f->next[d] = res;
            else root = res;
        }
        
        void insert(T val){
            insert(root, val);
        }
        
        void remove(T val){
            remove(root, val);
        }
        
        ScapegoatTreeNode<T>* findKth(int k){
            return findKth(root, k);
        }
};

int n;
int lb, rb;
ScapegoatTree<int> s;

inline void init() {
    readInteger(lb);
    readInteger(rb);
    for(int i = lb; i <= rb; i++){
        ScapegoatTreeNode<int>* node = new ScapegoatTreeNode<int>(i);
        readInteger(node->count);
        node->maintain();
        s.lis.push_back(node);
    }
    s.root = s.rebuild(0, s.lis.size() - 1);
}

inline void solve() {
    readInteger(n);
    char cmd[10];
    int a;
    while(n--) {
        scanf("%s", cmd);
        readInteger(a);
        if(cmd[0] == 'a'){
            s.insert(a);
        }else if(cmd[0] == 'd'){
            s.remove(a);
        }else{
            ScapegoatTreeNode<int>* node = s.findKth(a);
            printf("%d
", node->val);
        }
    }
}

int main(){
    freopen("kth.in", "r", stdin);
    freopen("kth.out", "w", stdout);
    init();
    solve();
    return 0;
}