Codeforces 765F Souvenirs

题目传送门

　　神速的列车

　　光速的列车

　　声速的列车

题目大意

　　给定一个长度为$n$的序列，$m$次询问区间$[l, r]$内相差最小的两个数的差的绝对值。

Solution 1 Mo's Algorithm & Linked List

　　不会。。果断莫队

　　当插入一个数的时候，如果用set维护前驱后继，然后结果是：$O((n + m)sqrt{n}log n)$，没救的，卡不过去。

　　但是感觉原序列不会改变，使用set维护很浪费。

　　考虑链表，链表上的每个数的后继是这个数的后继。

　　考虑可以通过排序提前得到大小关系，不断从链表中删数就能得到它在剩下的区间内的前后继。如果询问在同一个块内直接暴力。否则把答案分成三部分。

• 两个数都在当前块外，先从小到大加入剩下的所有数，从右到左删掉它们，再从左到右不断加入它们，然后就能得到所有前缀的答案。
• 两个数都在当前块内，处理出所有后缀的答案，做法类似。
• 一个在当前块内，一个在块外，移动右指针的时候让块内的所有数在链表内，查询的时候删掉再加入。

Code

/**
 * Codeforces
 * Problem#765F
 * Accepted
 * Time: 1309ms
 * Memory: 9400k
 */ 
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

#define pii pair<int, int>
#define fi first
#define sc second

const int cs = 350;
const signed int inf = (signed) (~0u >> 1);

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

int n, m;
int *ar;
pii *cr;
int *pre, *suf, *L;
Query *qs;

inline void init() {
    scanf("%d", &n);
    ar = new int[(n + 1)];
    cr = new pii[(n + 1)];
    pre = new int[(n + 2)];
    suf = new int[(n + 2)];
    L = new int[(n + 1)];
    for (int i = 1; i <= n; i++)
        scanf("%d", ar + i), cr[i].fi = ar[i], cr[i].sc = i;
    scanf("%d", &m);
    qs = new Query[(m + 1)];
    for (int i = 1; i <= m; i++) {
        scanf("%d%d", &qs[i].l, &qs[i].r);
        qs[i].lid = (qs[i].l - 1) / cs, qs[i].rid = (qs[i].r - 1) / cs;
        qs[i].id = i;
    }
}

void add(int p) {
    suf[pre[p]] = p;
    pre[suf[p]] = p;
}

void remove(int p) {
    suf[pre[p]] = suf[p];
    pre[suf[p]] = pre[p];
}

int update(int p) {
    int rt = inf;
    if (pre[p])
        rt = ar[p] - ar[pre[p]];
    if (suf[p] <= n)
        rt = min(rt, ar[suf[p]] - ar[p]);
    return rt;
}

inline void solve() {
    sort(cr + 1, cr + n + 1);
    sort(qs + 1, qs + m + 1);
    int c = 1;
    for (int sid = 0; sid <= n / cs && c <= m; sid++) {
        int mdzzr = min(cs * (sid + 1), n), ls = 0, lr = cs * sid, ce = mdzzr;
        
        pre[0] = 0, ls = 0;
        for (int i = 1; i <= n; i++) {
            pre[cr[i].sc] = ls;
            suf[ls] = cr[i].sc;
            ls = cr[i].sc;
        }
        suf[n + 1] = n + 1, pre[n + 1] = ls, suf[ls] = n + 1;
        
        for (int i = 1; i <= mdzzr; i++)
            remove(i);
        for (int i = n; i > mdzzr; i--)
            remove(i);
        L[mdzzr] = inf;
        for (int i = mdzzr + 1; i <= n; i++)
            add(i), L[i] = min(L[i - 1], update(i));
        for (int i = mdzzr; i > lr; i--)
            add(i);
        for (int i = n; i > mdzzr; i--)
            remove(i);
        
        for ( ; c <= m && qs[c].lid == sid; c++) {
            int l = qs[c].l, r = qs[c].r;
            if (qs[c].lid == qs[c].rid) {
                for (int i = lr + 1; i < l; i++)
                    remove(i);
                for (int i = mdzzr; i >= l; i--)
                    remove(i);
                int res = inf;
                for (int i = l; i <= r; i++)
                    add(i), res = min(res, update(i));
                for (int i = r + 1; i <= mdzzr; i++)
                    add(i);
                for (int i = l - 1; i > lr; i--)
                    add(i);
                qs[c].res = res;
            } else {
                while (mdzzr < r)
                    add(++mdzzr);
                int res = inf;
                for (int i = lr + 1; i <= ce; i++)
                    remove(i);
                for (int i = ce; i >= l; i--)
                    add(i), res = min(res, update(i));
                for (int i = l - 1; i > lr; i--)
                    add(i);
                qs[c].res = min(res, L[r]);
            }
        }
    }

    for (int i = 1; i <= m; i++)
        while (qs[i].id != i)
            swap(qs[i], qs[qs[i].id]);
    for (int i = 1; i <= m; i++)
        printf("%d
", qs[i].res);
}

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

Solution 2 Segment Tree

　　考虑将询问离线，然后分别考虑大于等于位置$i$上的数和小于等于它的数产生的贡献。从左到右扫描数组。

　　假设当前考虑以$r$为右端点的询问区间的答案。那么就要将$r$能产生的贡献计算出来。

　　能产生贡献的位置是在$r$前大于等于$a_r$的一个递减数列（从后向前）。根据它的期望长度是$log_{n}$的，用个线段树区间取min，就可以水掉bzoj上面的某道题。

　　于是cf上成功T掉了。

　　加一个很强的剪枝：新找到的数和$a_r$的差必须小于上一个找到的差的一半。

　　为什么是正确的呢？因为包含新找到的这个位置和$r$的区间一定包含上一个找到的数，但是显然新找到的数和上一个找到的数的差更优，会在另一次扫描中被统计。

　　至于查找上一个在某个值域内最后出现的数的位置，再开一棵线段树。

Code

/**
 * Codeforces
 * Problem#765F
 * Accepted
 * Time: 997ms
 * Memory: 28600k
 */
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;
typedef bool boolean;

const signed int inf = (signed) (~0u >> 1), Val = 1e9;

typedef class SegTreeNode {
    public:
        int val;
        SegTreeNode *l, *r;

        SegTreeNode() {    }

        void pushUp() {
            if (l)
                val = l->val;
            if (r)
                val = max(val, r->val);
        }
}SegTreeNode;

SegTreeNode pool[2000000];
SegTreeNode *top = pool;

SegTreeNode* newnode() {
    top->l = top->r = NULL;
    return top++;
}

typedef class SegTree {
    public:
        SegTreeNode* rt;

        SegTree():rt(NULL) {    }

        void update(SegTreeNode*& p, int l, int r, int ql, int qr, int val) {
            if (!p)
                p = newnode(), p->val = inf;
            if (l == ql && r == qr)    {
                p->val = min(p->val, val);
                return ;
            }
            int mid = (l + r) >> 1;
            if (qr <= mid)
                update(p->l, l, mid, ql, qr, val);
            else if (ql > mid)
                update(p->r, mid + 1, r, ql, qr, val);
            else {
                update(p->l, l, mid, ql, mid, val);
                update(p->r, mid + 1, r, mid + 1, qr, val);
            }
        }

        int query(SegTreeNode *p, int l, int r, int idx) {
            if (!p)
                return inf;
            if (l == r)
                return p->val;
            int mid = (l + r) >> 1, a = p->val, b = 0;
            if (idx <= mid)
                b = query(p->l, l, mid, idx);
            else
                b = query(p->r, mid + 1, r, idx);
            return min(a, b);
        }

        void update(SegTreeNode* &p, int l, int r, int idx, int val) {
            if (!p)
                p = newnode(), p->val = -1;
            if (l == r) {
                p->val = val;
                return;
            }
            int mid = (l + r) >> 1;
            if (idx <= mid)
                update(p->l, l, mid, idx, val);
            else
                update(p->r, mid + 1, r, idx, val);
            p->pushUp();
        }

        int query(SegTreeNode* p, int l, int r, int ql, int qr) {
            if (!p)
                return -1;
            if (l == ql && r == qr)
                return p->val;
            int mid = (l + r) >> 1;
            if (qr <= mid)
                return query(p->l, l, mid, ql, qr);
            if (ql > mid)
                return query(p->r, mid + 1, r, ql, qr);
            int a = query(p->l, l, mid, ql, mid);
            int b = query(p->r, mid + 1, r, mid + 1, qr);
            return max(a, b);
        }
}SegTree;

typedef class Query {
    public:
        int l, r, id, res;

        boolean operator < (Query b) const {
            return r < b.r;
        }
}Query;

int n, m;
int *ar;
SegTree st, stv;
Query* qs;

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

inline void solve() {
    sort(qs + 1, qs + m + 1);
    for (int s = 0, c = 0; s < 2; s++) {
        st.rt = stv.rt = NULL, top = pool, c = 1;
        for (int i = 1; i <= n; i++) {
            int rlim = Val, idx;
            while (ar[i] <= rlim && (idx = stv.query(stv.rt, 0, Val, ar[i], rlim)) != -1) {
                st.update(st.rt, 1, n, 1, idx, ar[idx] - ar[i]);
                rlim = ((ar[idx] + ar[i] - 1) >> 1);
            }
            stv.update(stv.rt, 0, Val, ar[i], i);
            for ( ; c <= m && qs[c].r == i; c++)
                qs[c].res = min(qs[c].res, st.query(st.rt, 1, n, qs[c].l));
        }
        for (int i = 1; i <= n; i++)
            ar[i] = Val - ar[i];
    }
    
    for (int i = 1; i <= m; i++)
        while (qs[i].id != i)
            swap(qs[i], qs[qs[i].id]);
    for (int i = 1; i <= m; i++)
        printf("%d ", qs[i].res);
}

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