主席树代码实现

// Code From ftiasch 
#include <cstdio>
#include <cstring>
#include <climits>
#include <algorithm>
using namespace std;

const int N = 111111;
const int INF = 1000000000;

struct Node {
    int minimum;
    Node *left, *right;

    Node(int m, Node *l, Node *r): minimum(m), left(l), right(r) {
    }
};

int n, m, coordinate[N], from[N], to[N], length[N], order[N];
Node* trees[N];

#define is_leaf (lower + 1 == upper)
#define mider ((lower + upper) >> 1)

Node* build(int lower, int upper) {
    if (lower >= upper) {
        return NULL;
    }
    return new Node(INF,
            is_leaf? NULL: build(lower, mider),
            is_leaf? NULL: build(mider, upper));
}

Node* insert(Node *root, int lower, int upper, int key, int value) {
    if (key < lower || upper <= key) {
        return root;
    }
    return new Node(min(root->minimum, value),
            is_leaf? NULL: insert(root->left, lower, mider, key, value),
            is_leaf? NULL: insert(root->right, mider, upper, key, value));
}

int query(Node *root, int lower, int upper, int key) {
    if (upper <= key) {
        return INF;
    }
    if (key <= lower) {
        return root->minimum;
    }
    return min(query(root->left, lower, mider, key),
            query(root->right, mider, upper, key));
}

#undef mider
#undef is_leaf

bool compare(int i, int j) {
    return to[i] < to[j];
}

int main() {
    scanf("%d%d", &n, &m);
    coordinate[0] = 0;
    for (int i = 0; i < n - 1; ++ i) {
        int length;
        scanf("%d", &length);
        coordinate[i + 1] = coordinate[i] + length;
    }
    for (int i = 0; i < m; ++ i) {
        scanf("%d%d%d", from + i, to + i, length + i);
        from[i] --;
        to[i] --;
    }
    for (int i = 0; i < m; ++ i) {
        order[i] = i;
    }
    // u <= from[i] to[i] <= v
    // form[i] - u + v - to[i]
    sort(order, order + m, compare);
    Node *tree = build(0, n);
    for (int iter = 0; iter < m; ++ iter) {
        int i = order[iter];
        tree = insert(tree, 0, n, from[i],
                coordinate[from[i]] - coordinate[to[i]] + length[i]);
        trees[iter] = tree;
    }
    int q;
    scanf("%d", &q);
    while (q > 0) {
        q --;
        int u, v;
        scanf("%d%d", &u, &v);
        u --;
        v --;
        int result = u <= v? coordinate[v] - coordinate[u]: INF;
        int lower = 0;
        int upper = m - 1;
        while (lower < upper) {
            int mider = (lower + upper + 1) >> 1;
            if (to[order[mider]] <= v) {
                lower = mider;
            } else {
                upper = mider - 1;
            }
        }
        if (lower <= upper) {
            Node *root = trees[lower];
            result = min(result,
                    query(root, 0, n, u) - coordinate[u] + coordinate[v]);
        }
        printf("%d\n", result);
    }
    return 0;
}

// 1 ~ N