SPOJ Meteors - 可持久化线段树 - 二分法

Byteotian Interstellar Union (BIU) has recently discovered a new planet in a nearby galaxy. The planet is unsuitable for colonisation due to strange meteor showers, which on the other hand make it an exceptionally interesting object of study.

The member states of BIU have already placed space stations close to the planet's orbit. The stations' goal is to take samples of the rocks flying by. The BIU Commission has partitioned the orbit into  sectors, numbered from  to , where the sectors  and  are adjacent. In each sector there is a single space station, belonging to one of the  member states.

Each state has declared a number of meteor samples it intends to gather before the mission ends. Your task is to determine, for each state, when it can stop taking samples, based on the meter shower predictions for the years to come.

Input

The first line of the standard input gives two integers,  and  (), separated by a single space, that denote, respectively, the number of BIU member states and the number of sectors the orbit has been partitioned into.

In the second line there are  integers  (), separated by single spaces, that denote the states owning stations in successive sectors.

In the third line there are  integers  (), separated by single spaces, that denote the numbers of meteor samples that the successive states intend to gather.

In the fourth line there is a single integer  () that denotes the number of meteor showers predictions. The following  lines specify the (predicted) meteor showers chronologically. The -th of these lines holds three integers , , (separated by single spaces), which denote that a meteor shower is expected in sectors  (if ) or sectors  (if ), which should provide each station in those sectors with  meteor samples ().

Output

Your program should print  lines on the standard output. The -th of them should contain a single integer , denoting the number of shower after which the stations belonging to the -th state are expected to gather at least  samples, or the wordNIE (Polish for no) if that state is not expected to gather enough samples in the foreseeable future.

Example

For the input data:

3 5
1 3 2 1 3
10 5 7
3
4 2 4
1 3 1
3 5 2

the correct result is:

3
NIE
1

---

　　题目大意 一个星球的环形轨道上有m个空间站，每个空间站属于n个国家中的一个，有k次流星雨，每次会使得一段空间站可以获得一些陨石，每个国家有个收集目标，问每个国家在第多少次流星雨后达成目标，或者无法达到目标。

　　将每次流星雨当成一次区间修改，修改可持久化线段树。用vector存下每个国家有哪些空间站。

　　然后枚举每个国家，二分答案，判断的时候暴力枚举每个国家的空间站，进行查询。

　　好在spoj不卡空间，bzoj空间直接卡死。然后我发现似乎我算节点数的时候忘记算常数了，发现内存池开小了很多，所以就动态开节点慢了许多。

Code

/**
 * SPOJ
 * Problem#METEORS
 * Accepted
 * Time:3220ms
 * Memory:521216k
 */
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

#define LL long long

typedef class SegTreeNode {
    public:
        LL val;
        LL lazy;
        SegTreeNode *l, *r;
        
        SegTreeNode():val(0), lazy(0), l(NULL), r(NULL) {        }
        
        inline void pushUp() {
            val = l->val + r->val;
        }
}SegTreeNode;

#define LIMIT 5600000
SegTreeNode pool[LIMIT + 1];
int top = 0;

inline SegTreeNode* newnode() {
    if(top >= LIMIT)    return new SegTreeNode();
    return &pool[top++];
}

inline SegTreeNode* newnode(SegTreeNode*& b) {
    if(top >= LIMIT) {
        SegTreeNode* p = new SegTreeNode();
        *p = *b;
        return p;
    }
    pool[top] = *b;
    return &pool[top++];
}

typedef class DurableSegTree {
    public:
        int now, n;
        SegTreeNode** ls;
        
        DurableSegTree() { }
        DurableSegTree(int n, int limit):now(0), n(n) {
            ls = new SegTreeNode*[(limit + 1)];
            build(ls[0], 1, n);
        } 
        
        void build(SegTreeNode*& node, int l, int r) {
            node = newnode();
            if(l == r)    return;
            int mid = (l + r) >> 1;
            build(node->l, l, mid);
            build(node->r, mid + 1, r);
        }
        
        void update(SegTreeNode*& old, SegTreeNode*& newo, int l, int r, int ql, int qr, LL val) {
            newo = newnode(old);
            if(ql > qr)    return;
            if(ql == l && qr == r) {
                newo->lazy += val;
                newo->l = old->l, newo->r = old->r; 
                return;
            }
            int mid = (l + r) >> 1;
            if(qr <= mid) {
                newo->r = old->r;
                update(old->l, newo->l, l, mid, ql, qr, val);
            } else if(ql > mid){
                newo->l = old->l;
                update(old->r, newo->r, mid + 1, r, ql, qr, val);
            } else {
                update(old->l, newo->l, l, mid, ql, mid, val);
                update(old->r, newo->r, mid + 1, r, mid + 1, qr, val);
            }
            newo->val += val * 1LL * (qr - ql + 1);
        }
        
        inline void update(int l, int r, LL val) {
            if(l <= r) {
                update(ls[now], ls[now + 1], 1, n, l, r, val);
            } else {
                update(ls[now], ls[now + 1], 1, n, r + 1, l - 1, -val);
                ls[now + 1]->lazy += val;
            }
            now++;
        } 
        
        void query(SegTreeNode*& node, int l, int r, int idx, LL& ret) {
            ret += node->lazy;
            if(l == idx && r == idx) {
                ret += node->val;
                return;
            }
            int mid = (l + r) >> 1;
            if(idx <= mid)    query(node->l, l, mid, idx, ret);
            else query(node->r, mid + 1, r, idx, ret);
        }
        
        inline LL query(int k, int pos) {
            LL ret = 0;
            query(ls[k], 1, n, pos, ret);
            return ret;
        }
}DurableSegTree;

int n, m, q;
vector<int> *owns;
int *goals;
DurableSegTree dst;

inline void init() {
    readInteger(n);
    readInteger(m);
    owns = new vector<int>[n + 1];
    goals = new int[(n + 1)];
    for(int i = 1, x; i <= m; i++) {
        readInteger(x);
        owns[x].push_back(i);
    }
    for(int i = 1; i <= n; i++)
        readInteger(goals[i]);

    readInteger(q);
    dst = DurableSegTree(m, q + 1);
    for(int i = 1, a, b, c; i <= q; i++) {
        readInteger(a);
        readInteger(b);
        readInteger(c);
        dst.update(a, b, c);
    }
}

boolean check(int country, int mid) {
    LL ret = 0;
    for(int i = 0; i < (signed)owns[country].size() && ret < goals[country]; i++)
        ret += dst.query(mid, owns[country][i]);
    return ret >= goals[country];
}

inline void solve() {
    for(int c = 1; c <= n; c++) {
        int l = 1, r = q;
        while(l <= r) {
            int mid = (l + r) >> 1;
            if(check(c, mid))    r = mid - 1;
            else l = mid + 1;
        }
        if(r == q)    puts("NIE");
        else printf("%d\n", r + 1);
    }
}

int main() {
//    freopen("meteors.in", "r", stdin);
    init();
    solve();
    return 0;
}