AcWing - 254 - 天使玩偶 = CDQ分治

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量207 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Inko/p/11469513.html
版权

下面是一种正确的CDQ分治，使用线段树来实现，渐进复杂度到达要求。但是貌似CDQ分治在解决偏序问题的时候要尽可能使用树状数组。小心不要把i和j写反了。下面这个写法虽然没有WA，但是TLE了，这个非常麻烦。事实上是因为有很多多余的操作影响了常数，比如多余的排序、没有用的修改、询问。当然这个线段树也可以换成几倍快的树状数组。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int INF = 1e9;
//将题目的[0,1e6]偏移到[1,1e6+1]
const int H = 1e6 + 1;

int st[H * 4 + 5];
inline void push_up(int o) {
    st[o] = min(st[o << 1], st[o << 1 | 1]);
}

void build(int o, int l, int r) {
    if(l == r) {
        st[o] = INF;
    } else {
        int mid = (l + r) >> 1;
        build(o << 1, l, mid);
        build(o << 1 | 1, mid + 1, r);
        push_up(o);
    }
}

void update(int o, int l, int r, int x, int v) {
    if(l == r) {
        st[o] = min(st[o], v);
    } else {
        int mid = (l + r) >> 1;
        if(x <= mid)
            update(o << 1, l, mid, x, v);
        else
            update(o << 1 | 1, mid + 1, r, x, v);
        push_up(o);
    }
}

void unupdate(int o, int l, int r, int x) {
    if(l == r) {
        st[o] = INF;
    } else {
        int mid = (l + r) >> 1;
        if(x <= mid)
            unupdate(o << 1, l, mid, x);
        else
            unupdate(o << 1 | 1, mid + 1, r, x);
        push_up(o);
    }
}

int query(int o, int l, int r, int ql, int qr) {
    if(ql <= l && r <= qr) {
        return st[o];
    } else {
        int mid = (l + r) >> 1, res = INF;
        if(ql <= mid)
            res = min(res, query(o << 1, l, mid, ql, qr));
        if(qr >= mid + 1)
            res = min(res, query(o << 1 | 1, mid + 1, r, ql, qr));
        return res;
    }
}

const int MAXNM = 1e6;

struct Query {
    int t, op, x, y, ans;
    bool operator<(const Query &q)const {
        return x < q.x;
    }
} q[MAXNM + 5], tq[MAXNM + 5];

inline int before_calc(int l, int r) {
    int tqtop = 0, mid = (l + r) >> 1;
    for(int i = l; i <= mid; ++i) {
        if(q[i].op == 1)
            tq[++tqtop] = q[i];
    }
    for(int i = mid + 1; i <= r; ++i) {
        if(q[i].op == 2)
            tq[++tqtop] = q[i];
    }
    sort(tq + 1, tq + 1 + tqtop);
    return tqtop;
}

inline void after_calc(int tqtop) {
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 1)
            unupdate(1, 1, H, tq[i].y);
        else
            q[tq[i].t].ans = tq[i].ans;
    }
}

int calc_upleft(int tqtop) {
    for(int i = 1, nxt; i <= tqtop; i = nxt) {
        for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
        for(int j = i; j < nxt; ++j) {
            if(tq[j].op == 1)
                update(1, 1, H, tq[j].y, (-tq[j].x + tq[j].y));
        }
        for(int j = i; j < nxt; ++j) {
            if(tq[j].op == 2)
                tq[j].ans = min(tq[j].ans, (tq[j].x - tq[j].y) + query(1, 1, H, tq[j].y, H));
        }
    }
    after_calc(tqtop);
}

int calc_downleft(int tqtop) {
    for(int i = 1, nxt; i <= tqtop; i = nxt) {
        for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
        for(int j = i; j < nxt; ++j) {
            if(tq[j].op == 1)
                update(1, 1, H, tq[j].y, (-tq[j].x - tq[j].y));
        }
        for(int j = i; j < nxt; ++j) {
            if(tq[j].op == 2)
                tq[j].ans = min(tq[j].ans, (tq[j].x + tq[j].y) + query(1, 1, H, 1, tq[j].y));
        }
    }
    after_calc(tqtop);
}

int calc_upright(int tqtop) {
    for(int i = tqtop, nxt; i >= 1; i = nxt) {
        for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
        for(int j = i; j > nxt; --j) {
            if(tq[j].op == 1)
                update(1, 1, H, tq[j].y, (tq[j].x + tq[j].y));
        }
        for(int j = i; j > nxt; --j) {
            if(tq[j].op == 2)
                tq[j].ans = min(tq[j].ans, (-tq[j].x - tq[j].y) + query(1, 1, H, tq[j].y, H));
        }
    }
    after_calc(tqtop);
}

int calc_downright(int tqtop) {
    for(int i = tqtop, nxt; i >= 1; i = nxt) {
        for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
        for(int j = i; j > nxt; --j) {
            if(tq[j].op == 1)
                update(1, 1, H, tq[j].y, (tq[j].x - tq[j].y));
        }
        for(int j = i; j > nxt; --j) {
            if(tq[j].op == 2)
                tq[j].ans = min(tq[j].ans, (-tq[j].x + tq[j].y) + query(1, 1, H, 1, tq[j].y));
        }
    }
    after_calc(tqtop);
}

void solve(int l, int r) {
    if(l == r)
        return;
    int mid = (l + r) >> 1;
    solve(l, mid);
    solve(mid + 1, r);

    //这里是没必要每一层都排序的，事实上是每一层直接归并就可以了
    int tqtop = before_calc(l, r);
    calc_upleft(tqtop);
    calc_downleft(tqtop);
    calc_upright(tqtop);
    calc_downright(tqtop);
    return;
}

int main() {
#ifdef Yinku
    freopen("Yinku.in", "r", stdin);
#endif // Yinku
    int n, m;
    scanf("%d%d", &n, &m);
    int qtop = 0;
    for(int i = 1; i <= n; ++i) {
        int x, y;
        scanf("%d%d", &x, &y);
        ++qtop;
        q[qtop].op = 1;
        q[qtop].t = qtop;
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
        q[qtop].ans = INF;
    }
    for(int i = 1; i <= m; ++i) {
        int op, x, y;
        scanf("%d%d%d", &op, &x, &y);
        ++qtop;
        q[qtop].op = op;
        q[qtop].t = qtop;
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
        q[qtop].ans = INF;
    }
    build(1, 1, H);
    solve(1, qtop);
    for(int i = 1; i <= qtop; ++i) {
        if(q[i].op == 2) {
            printf("%d\n", q[i].ans);
        }
    }
}

加上快读，换成树状数组，树状数组修改时跳过不可能更新到当前询问的修改，换成归并排序，然后CDQ剪枝（某分支的操作类型全部是修改操作时，该分支没有任何询问会被更新，直接按x排序并返回该分支）。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

namespace FastIO {
#define BUF_SIZE 1000000
    bool IOError = 0;
    inline char NextChar() {
        static char buf[BUF_SIZE], *pl = buf + BUF_SIZE, *pr = buf + BUF_SIZE;
        if(pl == pr) {
            pl = buf, pr = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pr == pl) {
                IOError = 1;
                return -1;
            }
        }
        return *pl++;
    }
#undef BUF_SIZE

    inline bool Blank(char c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t';
    }

    template<class T> inline void Read(T &x) {
        char c;
        while(Blank(c = NextChar()));
        if(!IOError) {
            for(x = 0; '0' <= c && c <= '9'; c = NextChar())
                x = (x << 3) + (x << 1) + c - '0';
        }
    }

    template<class T> inline void Read2(T &x) {
        char c;
        bool f = 0;
        while(Blank(c = NextChar()));
        if(!IOError) {
            if(c == '-') {
                f = 1;
                c = NextChar();
            }
            for(x = 0; '0' <= c && c <= '9'; c = NextChar())
                x = (x << 3) + (x << 1) + c - '0';
        }
        if(f)
            x = -x;
    }

    template<class T> inline void PutChar(T x) {
        if(x > 9)
            PutChar(x / 10);
        putchar(x % 10 + '0');
    }

    template<class T> inline void Write(T &x) {
        PutChar(x);
        putchar('\n');
    }

    template<class T> inline void Write2(T &x) {
        if(x < 0) {
            putchar('-');
            PutChar(-x);
        } else
            PutChar(x);
        putchar('\n');
    }
}

using namespace FastIO;

const int INF = 1e9;
//将题目的[0,1e6]偏移到[1,1e6+1]
const int H = 1e6 + 1;

int bit[H + 5];

void build() {
    for(int i = 1; i <= H; ++i)
        bit[i] = INF;
}

void update(int x, int v) {
    for(; x <= H; x += x & -x)
        bit[x] = min(bit[x], v);
}

void unupdate(int x) {
    for(; x <= H; x += x & -x)
        bit[x] = INF;
}

int query(int x) {
    int res = INF;
    for(; x >= 1; x -= x & -x)
        res = min(res, bit[x]);
    return res;
}

const int MAXNM = 1e6;

struct Query {
    int t, op, x, y, ans;
    bool operator<(const Query &q)const {
        return x < q.x;
    }
} q[MAXNM + 5], tq[MAXNM + 5], tq2[MAXNM + 5];

bool cmp(const Query &q1, const Query &q2) {
    return q1.t < q2.t;
}

inline int before_calc(int l, int r) {
    int mid = (l + r) >> 1;
    int tqtop = 0;
    for(int i = l; i <= mid; ++i) {
        if(q[i].op == 1) {
            tq[++tqtop] = q[i];
            tq[tqtop].t = i;
        }
    }
    int l1 = tqtop;
    for(int i = mid + 1; i <= r; ++i) {
        if(q[i].op == 2) {
            tq[++tqtop] = q[i];
            tq[tqtop].t = i;
        }
    }
    int l2 = tqtop;

    merge(tq + 1, tq + 1 + l1, tq + 1 + l1, tq + 1 + l2, tq2 + 1);
    for(int j = 1; j <= l2; ++j) {
        tq[j] = tq2[j];
    }
    return l2;
}

inline void after_calc(int l, int r, int tqtop) {
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 2)
            q[tq[i].t].ans = tq[i].ans;
    }
    int mid = (l + r) >> 1;
    merge(q + l, q + mid + 1, q + mid + 1, q + r + 1, tq2 + 1);
    for(int j = l; j <= r; ++j) {
        q[j] = tq2[j - l + 1];
    }
}

int calc_upleft(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 2)
            maxy = max(maxy, H - tq[i].y + 1);
    }
    if(maxy != INF) {
        for(int i = 1, nxt; i <= tqtop; i = nxt) {
            for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op == 1 && H - tq[j].y + 1 <= maxy)
                    update(H - tq[j].y + 1, (-tq[j].x + tq[j].y));
            }
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op == 2)
                    tq[j].ans = min(tq[j].ans, (tq[j].x - tq[j].y) + query(H - tq[j].y + 1));
            }
        }
        for(int i = 1; i <= tqtop; ++i) {
            if(tq[i].op == 1 && H - tq[i].y + 1 <= maxy)
                unupdate(H - tq[i].y + 1);
        }
    }
}

int calc_downleft(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 2)
            maxy = max(maxy, tq[i].y);
    }
    if(maxy != INF) {
        for(int i = 1, nxt; i <= tqtop; i = nxt) {
            for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op == 1 && tq[j].y <= maxy)
                    update(tq[j].y, (-tq[j].x - tq[j].y));
            }
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op == 2)
                    tq[j].ans = min(tq[j].ans, (tq[j].x + tq[j].y) + query(tq[j].y));
            }
        }
        for(int i = 1; i <= tqtop; ++i) {
            if(tq[i].op == 1 && tq[i].y <= maxy)
                unupdate(tq[i].y);
        }
    }
}

int calc_upright(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 2)
            maxy = max(maxy, H - tq[i].y + 1);
    }
    if(maxy != INF) {
        for(int i = tqtop, nxt; i >= 1; i = nxt) {
            for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
            for(int j = i; j > nxt; --j) {
                if(tq[j].op == 1 && H - tq[j].y + 1 <= maxy)
                    update(H - tq[j].y + 1, (tq[j].x + tq[j].y));
            }
            for(int j = i; j > nxt; --j) {
                if(tq[j].op == 2)
                    tq[j].ans = min(tq[j].ans, (-tq[j].x - tq[j].y) + query(H - tq[j].y + 1));
            }
        }
        for(int i = 1; i <= tqtop; ++i) {
            if(tq[i].op == 1 && H - tq[i].y + 1 <= maxy)
                unupdate(H - tq[i].y + 1);
        }
    }
}

int calc_downright(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(tq[i].op == 2)
            maxy = max(maxy, tq[i].y);
    }
    if(maxy != INF) {
        for(int i = tqtop, nxt; i >= 1; i = nxt) {
            for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
            for(int j = i; j > nxt; --j) {
                if(tq[j].op == 1 && tq[j].y <= maxy)
                    update(tq[j].y, (tq[j].x - tq[j].y));
            }
            for(int j = i; j > nxt; --j) {
                if(tq[j].op == 2)
                    tq[j].ans = min(tq[j].ans, (-tq[j].x + tq[j].y) + query(tq[j].y));
            }
        }
        for(int i = 1; i <= tqtop; ++i) {
            if(tq[i].op == 1 && tq[i].y <= maxy)
                unupdate(tq[i].y);
        }
    }
}

void solve(int l, int r) {

    if(l == r)
        return;
    int mid = (l + r) >> 1;
    bool allupdate = true;
    for(int i = l; i <= mid; i++) {
        if(q[i].op == 2) {
            allupdate = false;
            break;
        }
    }
    if(!allupdate)
        solve(l, mid);
    else
        sort(q + l, q + 1 + mid);
    bool allupdate2 = true;
    for(int i = mid + 1; i <= r; i++) {
        if(q[i].op == 2) {
            allupdate2 = false;
            break;
        }
    }
    if(!allupdate2)
        solve(mid + 1, r);
    else
        sort(q + mid + 1, q + 1 + r);

    if(allupdate && allupdate2)
        return;
    //这里是没必要每一层都排序的，事实上是每一层直接归并就可以了
    int tqtop = before_calc(l, r);
    calc_upleft(tqtop);
    calc_downleft(tqtop);
    calc_upright(tqtop);
    calc_downright(tqtop);
    after_calc(l, r, tqtop);
    return;
}


int main() {
#ifdef Yinku
    freopen("Yinku.in", "r", stdin);
#endif // Yinku
    int n, m;
    Read(n), Read(m);
    //scanf("%d%d", &n, &m);
    int qtop = 0;
    for(int i = 1; i <= n; ++i) {
        int x, y;
        Read(x), Read(y);
        //scanf("%d%d", &x, &y);
        ++qtop;
        q[qtop].op = 1;
        q[qtop].t = qtop;
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
        q[qtop].ans = INF;
    }
    for(int i = 1; i <= m; ++i) {
        int op, x, y;
        Read(op), Read(x), Read(y);
        //scanf("%d%d%d", &op, &x, &y);
        ++qtop;
        q[qtop].op = op;
        q[qtop].t = qtop;
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
        q[qtop].ans = INF;
    }
    build();
    solve(1, qtop);
    sort(q + 1, q + 1 + qtop, cmp);
    for(int i = 1; i <= qtop; ++i) {
        if(q[i].op == 2) {
            Write(q[i].ans);
            //printf("%d\n", q[i].ans);
        }
    }
}

AcWing上面还对空间作出要求，把ans项剥离出去，然后把t和op两个整数合成一个，算一下貌似原来刚好够64MB。原本是：20+20+20+4，改了之后是12+12+12+4+4，是绰绰有余。然后把CDQ剪枝换了一下位置，应该再加上一层常数优化的，就是第一层不检测剪枝直接递归下去，也不进行最后一次归并。然后，还可以统计实际上插入树状数组中的数的个数，当插入的数过多时不进行撤销树状数组，直接整棵重建（毕竟memset比一堆判断、与、加减、赋值的树状数组快得多）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

namespace FastIO {
#define BUF_SIZE 1000000
    bool IOError = 0;
    inline char NextChar() {
        static char buf[BUF_SIZE], *pl = buf + BUF_SIZE, *pr = buf + BUF_SIZE;
        if(pl == pr) {
            pl = buf, pr = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pr == pl) {
                IOError = 1;
                return -1;
            }
        }
        return *pl++;
    }
#undef BUF_SIZE

    inline bool Blank(char c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t';
    }

    template<class T> inline void Read(T &x) {
        char c;
        while(Blank(c = NextChar()));
        if(!IOError) {
            for(x = 0; '0' <= c && c <= '9'; c = NextChar())
                x = (x << 3) + (x << 1) + c - '0';
        }
    }

    template<class T> inline void Read2(T &x) {
        char c;
        bool f = 0;
        while(Blank(c = NextChar()));
        if(!IOError) {
            if(c == '-') {
                f = 1;
                c = NextChar();
            }
            for(x = 0; '0' <= c && c <= '9'; c = NextChar())
                x = (x << 3) + (x << 1) + c - '0';
        }
        if(f)
            x = -x;
    }

    template<class T> inline void PutChar(T x) {
        if(x > 9)
            PutChar(x / 10);
        putchar(x % 10 + '0');
    }

    template<class T> inline void Write(T &x) {
        PutChar(x);
        putchar('\n');
    }

    template<class T> inline void Write2(T &x) {
        if(x < 0) {
            putchar('-');
            PutChar(-x);
        } else
            PutChar(x);
        putchar('\n');
    }
}

using namespace FastIO;

const int INF = 0x3f3f3f3f;
//将题目的[0,1e6]偏移到[1,1e6+1]
const int H = 1e6 + 1;

int bit[H + 5];

inline void build() {
    memset(bit, INF, sizeof(bit));
}

void update(int x, int v) {
    for(; x <= H; x += x & -x) {
        if(v < bit[x])
            bit[x] = v;
    }
}

void unupdate(int x) {
    for(; x <= H; x += x & -x)
        bit[x] = INF;
}

int query(int x) {
    int res = INF;
    for(; x >= 1; x -= x & -x) {
        if(bit[x] < res)
            res = bit[x];
    }
    return res;
}

const int MAXNM = 1e6;

struct Query {
    int op, x, y;
    bool operator<(const Query &q)const {
        return x < q.x;
    }
} q[MAXNM + 5], tq[MAXNM + 5], tq2[MAXNM + 5];

inline int before_calc(int l, int r) {
    int mid = (l + r) >> 1;
    int tqtop = 0;
    for(int i = l; i <= mid; ++i) {
        if(q[i].op & 1)
            tq[++tqtop] = q[i];
    }
    int l1 = tqtop;
    for(int i = mid + 1; i <= r; ++i) {
        if(!(q[i].op & 1))
            tq[++tqtop] = q[i];
    }
    int l2 = tqtop;

    merge(tq + 1, tq + 1 + l1, tq + 1 + l1, tq + 1 + l2, tq2 + 1);
    for(int j = 1; j <= l2; ++j)
        tq[j] = tq2[j];
    return l2;
}

inline void after_calc(int l, int r, int tqtop) {
    int mid = (l + r) >> 1;
    merge(q + l, q + mid + 1, q + mid + 1, q + r + 1, tq2 + 1);
    for(int j = l; j <= r; ++j)
        q[j] = tq2[j - l + 1];
}

int ans[MAXNM + 5];

//超过该界时不进行取消树状数组，直接重建，因为树状数组有很多加法、判断之类的，而memset快得多
const int BUILDLIMIT = 5e4;

int calc_upleft(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(!(tq[i].op & 1))
            maxy = max(maxy, H - tq[i].y + 1);
    }
    if(maxy != INF) {
        int cnt = 0;
        for(int i = 1, nxt; i <= tqtop; i = nxt) {
            for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op & 1 && H - tq[j].y + 1 <= maxy) {
                    update(H - tq[j].y + 1, (-tq[j].x + tq[j].y));
                    ++cnt;
                }
            }
            for(int j = i; j < nxt; ++j) {
                if(!(tq[j].op & 1))
                    ans[tq[j].op >> 1] = min(ans[tq[j].op >> 1], (tq[j].x - tq[j].y) + query(H - tq[j].y + 1));

            }
        }
        if(cnt < BUILDLIMIT) {
            for(int i = 1; i <= tqtop; ++i) {
                if(tq[i].op & 1 && H - tq[i].y + 1 <= maxy)
                    unupdate(H - tq[i].y + 1);
            }
        } else
            build();
    }
}

int calc_downleft(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(!(tq[i].op & 1))
            maxy = max(maxy, tq[i].y);
    }
    if(maxy != INF) {
        int cnt = 0;
        for(int i = 1, nxt; i <= tqtop; i = nxt) {
            for(nxt = i + 1; nxt <= tqtop && tq[i].x == tq[nxt].x; ++nxt);
            for(int j = i; j < nxt; ++j) {
                if(tq[j].op & 1 && tq[j].y <= maxy) {
                    update(tq[j].y, (-tq[j].x - tq[j].y));
                    ++cnt;
                }
            }
            for(int j = i; j < nxt; ++j) {
                if(!(tq[j].op & 1))
                    ans[tq[j].op >> 1] = min(ans[tq[j].op >> 1], (tq[j].x + tq[j].y) + query(tq[j].y));
            }
        }
        if(cnt < BUILDLIMIT) {
            for(int i = 1; i <= tqtop; ++i) {
                if(tq[i].op & 1 && tq[i].y <= maxy)
                    unupdate(tq[i].y);
            }
        } else
            build();
    }
}

int calc_upright(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(!(tq[i].op & 1))
            maxy = max(maxy, H - tq[i].y + 1);
    }
    if(maxy != INF) {
        int cnt = 0;
        for(int i = tqtop, nxt; i >= 1; i = nxt) {
            for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
            for(int j = i; j > nxt; --j) {
                if(tq[j].op & 1 && H - tq[j].y + 1 <= maxy) {
                    update(H - tq[j].y + 1, (tq[j].x + tq[j].y));
                    ++cnt;
                }
            }
            for(int j = i; j > nxt; --j) {
                if(!(tq[j].op & 1))
                    ans[tq[j].op >> 1] = min(ans[tq[j].op >> 1], (-tq[j].x - tq[j].y) + query(H - tq[j].y + 1));
            }
        }
        if(cnt < BUILDLIMIT) {
            for(int i = 1; i <= tqtop; ++i) {
                if(tq[i].op & 1 && H - tq[i].y + 1 <= maxy)
                    unupdate(H - tq[i].y + 1);
            }
        } else
            build();
    }
}

int calc_downright(int tqtop) {
    int maxy = -INF;
    for(int i = 1; i <= tqtop; ++i) {
        if(!(tq[i].op & 1))
            maxy = max(maxy, tq[i].y);
    }
    if(maxy != INF) {
        int cnt = 0;
        for(int i = tqtop, nxt; i >= 1; i = nxt) {
            for(nxt = i - 1; nxt >= 1 && tq[i].x == tq[nxt].x; --nxt);
            for(int j = i; j > nxt; --j) {
                if(tq[j].op & 1 && tq[j].y <= maxy) {
                    ++cnt;
                    update(tq[j].y, (tq[j].x - tq[j].y));
                }
            }
            for(int j = i; j > nxt; --j) {
                if(!(tq[j].op & 1))
                    ans[tq[j].op >> 1] = min(ans[tq[j].op >> 1], (-tq[j].x + tq[j].y) + query(tq[j].y));
            }
        }
        if(cnt < BUILDLIMIT) {
            for(int i = 1; i <= tqtop; ++i) {
                if(tq[i].op & 1 && tq[i].y <= maxy)
                    unupdate(tq[i].y);
            }
        } else
            build();
    }
}

void solve(int l, int r, bool firstlayer = false) {
    if(l == r)
        return;
    if(!firstlayer) {
        bool all1 = true;
        for(int i = l; i <= r ; i++) {
            if(!(tq[i].op & 1)) {
                all1 = false;
                break;
            }
        }
        if(all1) {
            sort(q + l, q + r + 1);
            return;
        }
    }
    int mid = (l + r) >> 1;
    solve(l, mid);
    solve(mid + 1, r);
    //这里是没必要每一层都排序的，事实上是每一层直接归并就可以了
    int tqtop = before_calc(l, r);
    calc_upleft(tqtop);
    calc_downleft(tqtop);
    calc_upright(tqtop);
    calc_downright(tqtop);
    if(!firstlayer)
        after_calc(l, r, tqtop);
    return;
}


int main() {
#ifdef Yinku
    freopen("Yinku.in", "r", stdin);
#endif // Yinku
    int n, m;
    Read(n), Read(m);
    //scanf("%d%d", &n, &m);
    int qtop = 0;
    for(int i = 1; i <= n; ++i) {
        int x, y;
        Read(x), Read(y);
        ++qtop;
        q[qtop].op = qtop << 1 | 1;
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
    }
    for(int i = 1; i <= m; ++i) {
        int op, x, y;
        Read(op), Read(x), Read(y);
        ++qtop;
        q[qtop].op = (qtop << 1) | (op & 1);
        q[qtop].x = x + 1;
        q[qtop].y = y + 1;
    }
    build();
    memset(ans, INF, sizeof(ans[0]) * (n + m + 1));
    solve(1, qtop, true);
    const int MAXANS = 5e6;
    for(int i = 1; i <= qtop; ++i) {
        if(ans[i] <= MAXANS) {
            Write(ans[i]);
        }
    }
}

需要注意的是文件快读和普通快读在O2的时候会导致这题RE，区域赛小心一点。

发现还有一种渐进复杂度更好的办法，或许可以代替掉全修改剪枝，就是把初始点的n个丢进去树状数组把后面m个点中的询问拉出来更新，四个维度各做一次，然后前面n个点就彻底没用了，只对后面的m个点做CDQ分治。

转载于:https://www.cnblogs.com/Inko/p/11469513.html

aoying6521
关注
CDQ分治详解
m0_57344422的博客
05-22 1560
CDQ分治
[cdq分治习题练习]
MekakuCityActors的博客
08-20 556
bzoj1935 题意：给出n棵树的位置(xi,yi)，有m次询问，每次询问一个以(Xi,Yi)为左下角，(Li,Ri)为右上角的矩形内树的个数 题解：显然的三维偏序问题，一维是询问的时间T，一维是横坐标，一维是纵坐标。把初始的n棵树的位置当作插入，把询问当成4个二维前缀和相加减，由于时间是按照输入的顺序，所以第一维不需要排序，直接cdq分治处理第二维，树状数组维护第三维即可 /*********...
[BZOJ2716][天使玩偶angel][CDQ分治]
羽裳
02-24 2207
[BZOJ2716][天使玩偶angel][CDQ分治]题目大意： 先给出n个点, 然后有m个操作, (1, x, y) 表示查询离(x, y)最近点的曼哈顿距离, (2, x, y) 表示插入点 (x, y)。 CDQ分治相关：这道题在线的话是可以用KD-Tree维护平面上的点集。但是既然题目没有要求在线那就用CDQ分治做好了。CDQ分治是一种离线的分治算法。对于一个数据结构问题，无非存在两种
【bzoj 2716】[Violet 3]天使玩偶 （cdq分治+树状数组）
weixin_30256505的博客
09-11 757
2716: [Violet 3]天使玩偶 Time Limit:80 SecMemory Limit:128 MBSubmit:1241Solved:546 [Submit][Status][Discuss] Description Input Output Sample Input 100 100 81 23 27 16 ...
天使玩偶 [CDQ分治]
FSYo 的博客
01-14 498
传送门 我们可以将这些操作看成(x,y,t) 三元组 , 表示x,y坐标 , 与时间 CDQ 分治时 将前一半时间的修改提出来 , 再将后一半时间的询问提出来 然后按x 排序 , 这样就是一个二维偏序了 , 但是有一个问题 , 我们如何求dis 发现可以分4种情况 , 这里拿左下举个例子 我们发现  于是 x 按顺序插入 , 在树状数组的y 的位置插入(xi + yi) , 询问就是x...
Acwing 254. 天使玩偶
Mystletainn的博客
08-09 339
Ayu在七年前曾经收到过一个天使玩偶，当时她把它当做时间囊埋在了地下。 而七年后的今天，Ayu却忘了她把天使玩偶埋在了哪里，所以她决定仅凭一点模糊的记忆来寻找它。 我们把Ayu生活的小镇看做一个二维平面直角坐标系，而Ayu会不定时的记起可能在某个点(x,y)埋下了天使玩偶。 或者Ayu会询问你，假如她在(x,y)，那么她离最近的天使玩偶可能埋下的地方有多远。 因为Ayu只会沿着平行坐标轴的方向来行...
洛谷P4169 [Violet]天使玩偶【CDQ分治】
niiick
08-29 895
时空限制 2000ms-3000ms / 128MB 题目描述 Ayu 在七年前曾经收到过一个天使玩偶，当时她把它当作时间囊埋在了地下。而七年后 的今天，Ayu 却忘了她把天使玩偶埋在了哪里，所以她决定仅凭一点模糊的记忆来寻找它。 我们把 Ayu 生活的小镇看作一个二维平面坐标系，而 Ayu 会不定时地记起可能在某个点 (xmy) 埋下了天使玩偶；或者 Ayu 会询问你，假如她在 (x,y)...
【模板】分治FFT -cdq分治/多项式求逆
远行客
11-21 341
分治 FFT
Stars POJ - 2352 二维偏序问题CDQ分治
why932346109的博客
08-13 274
Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and ...
BZOJ 1176[Balkan2007]Mokia （cdq分治，矩阵加矩阵求和）
Dch19990825的博客
09-25 381
BZOJ 1176[Balkan2007]Mokia （cdq分治解三维偏序） Description 维护一个W*W的矩阵，初始值均为S.每次操作可以增加某格子的权值,或询问某子矩阵的总权值.修改操作数M<=160000,询问数Q<=10000,W<=2000000. Input 第一行两个整数,S,W;其中S为矩阵初始值;W为矩阵大小 接下来每行为一下三种输入之一(不包含引号...
bzoj 2716: [Violet 3]天使玩偶（cdq分治）
clover_hxy的博客
09-10 5439
2716: [Violet 3]天使玩偶 Time Limit: 80 Sec  Memory Limit: 128 MB Submit: 1231  Solved: 541 [Submit][Status][Discuss] Description Input Output Sample Input 100 100 81 23 27 1
bzoj2716 [Violet 3]天使玩偶（CDQ分治）
Coco_T的博客
12-14 1475
前言：我们又回到了这道题，不过这次我们选择一个常数小一点的算法：CDQ Description InputOutputSample Input 100 100 81 23 27 16 52 58 44 24 25 95 34 2 96 25 8 14 97 50 97 18 64 3 47 22 55 28 89 37 75 45 67 22 90 8 65 45 68 93 87 8 61 45
BZOJ-2716-天使玩偶angel-CDQ分治
ghy1953
03-28 6683
描述 先给出n个点, 然后有m个操作, (1, x, y) 表示查询离(x, y)最近点的曼哈顿距离, (2, x, y) 表示插入点 (x, y). 分析 不会做... 又照着别人的代码打了一遍... CDQ分治总想不到思路比较关键的几个地方是 : 1. 坐标的范围是小于1000000的所以可以用树状数组维护. 2. 距离点(x, y)最近的点和x的方位有四种, 左下左上右
天使玩偶（CDQ分治+最小曼哈顿距离）
UniverseofHK的博客
09-03 395
天使玩偶 题意：有两种操作： 给二维平面上加入一个点 询问二维平面上到某个点最近的一个点（用曼哈顿距离来表示） 思路：标准的CDQ分治，离线处理两种操作 当想到CDQ分治后本题的重点在于如何处理曼哈顿距离，毕竟看到绝对值都头疼 我们最希望的是能去掉绝对值！这里有一种处理方法：我们只考虑每个询问点左下角的点，则显然可以去掉绝对值，用普通的CDQ分治，按照xxx坐标排序，按照yyy坐标将x+yx...
P4169 [Violet]天使玩偶/SJY摆棋子
weixin_33692284的博客
12-07 993
传送门 用kdtree重新抄写了一遍 然后发现kdtree竟然跑的比CDQ快？ 也是很神奇了…… //minamoto #include<bits/stdc++.h> #define R register #define inf 0x3f3f3f3f #define fp(i,a,b) for(R int i=a,I=b+1;i<I;++i) #define fd(i,a,b)...
Acwing 854. Floyd求最短路
Allen的博客
03-18 490
题目 给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。 再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出impossible。 数据保证图中不存在负权回路。 输入格式 第一行包含三个整数n,m,k。 接下来m行，每行包含三个整数x,y,z，表示存在一条从点xx到点y的有向边，边长为z。 接下来k行，每行包含两个整数x,y，表示询问点x到点y的最短距离。 ...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 346
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
任务安排 cdq分治
12-23
任务安排CDQ分治是一种常用的算法设计技巧，主要用于解决一些复杂的问题。CDQ分治算法通常用于解决一些与区间相关的问题，如区间覆盖、区间查询等。 CDQ分治算法的思想是将原始问题分解成若干个子问题，然后分别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值