2019 ICPC North American Qualifier Contest L题 Traveling Merchant

题意

一条线上有$N(\le 10^5)$个城市，标号从$1$到$N$。每个城市物价根据星期的不同而有所不同，具体来说，每个城市有原价$v_i$，变动$d_i$，周一到周日的变化量为 { + 0 , + v i , + 2 v i , + 3 v i , + 2 v i , + v i , + 0 } \{+0, +v_i, +2v_i, +3v_i, +2v_i, +v_i, +0\} {+0,+vi​,+2vi​,+3vi​,+2vi​,+vi​,+0}。现在有$Q(\le 10^5)$个询问，每个询问商人会从$l$号城市往$r$号城市旅行，$l$有可能大于$r$，此时要逆行。求次旅行最大的差价$(pric{e}_j-pric{e}_i)(j>i)$是多少。

解题思路

$10^5$数据量+$10^5$查询，那么很明显直接模拟是不行的，但是这题题意看起来用线段树也不太好维护（有可能是我太菜了不会）。于是有没有又好维护跑的又快的数据结构呢？于是祭出分块大法。
我们可以把所有城市按照标号分成$\sqrt{N}$块，每一块内存储3个信息 { 整 块 内 最 大 价 格 ， 整 块 内 最 小 价 格 ， 整 块 内 最 大 差 价 } \{整块内最大价格，整块内最小价格，整块内最大差价\} {整块内最大价格，整块内最小价格，整块内最大差价}。这样查询的时候可以两端直接模拟，中间根据这三个信息更新最大差价，每次查询复杂度不会超过$O(\sqrt{N})$。
由于有星期这个设定，所以我们要维护$7$重块，每个块信息代表当从第$k$天开始从左到右（反向旅行同理）旅行的信息。这个问题便迎刃而解了，看官方题解好像是用的线段树，但是感觉应该很难写，我用分块一发就过了，线段树不知道要调多久。

时间复杂度

$O(N+Q\sqrt{N})$

代码

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>

typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 1e18;
const double INFD = 1e30;
const double EPS = 1e-6;
const double PI = 3.14159265;
const ll MOD = 1e9 + 7;

template <typename T>
inline T read() {
    T X = 0, w = 0;
    char ch = 0;
    while (!isdigit(ch)) {
        w |= ch == '-';
        ch = getchar();
    }
    while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
    return w ? -X : X;
}

const int MAXN = 100005;
int n, m, k;

struct Info {
    int v, d, b;
};

// 块信息，最大值，最小值，最大差值，左右延伸范围
struct Block {
    int maxx;
    int minn;
    int maxprofit;
    int lft;
    int rgt;
};
int raise[7] = {0, 1, 2, 3, 2, 1, 0};
int CASE;
// 正向旅行块
Block blocks[7][505];
// 反向旅行块
Block blocks2[7][505];
int B;
Info cities[MAXN];

// 正向计算
void cal(int l, int r, int d, int& maxx, int& minn, int& maxprofit) {
    for (int j = l; j <= r; j++) {
        int day = (j - l + d) % 7;
        int price = cities[j].v + raise[day] * cities[j].d;
        minn = min(minn, price);
        maxprofit = max(maxprofit, price - minn);
        maxx = max(maxx, price);
    }
}

// 反向计算
void cal2(int r, int l, int d, int& maxx, int& minn, int& maxprofit) {
    for (int j = r; j >= l; j--) {
        int day = (r - j + d) % 7;
        int price = cities[j].v + raise[day] * cities[j].d;
        minn = min(minn, price);
        maxprofit = max(maxprofit, price - minn);
        maxx = max(maxx, price);
    }
}

// 同样也是一正一反
int query2(int r, int l) {
    int d = 0;
    int maxx = 0, minn = 1e9, prof = 0;
    int rs = max(l, blocks2[0][cities[r].b].lft);
    cal2(r, rs, d, maxx, minn, prof);
    d = (d + r - rs + 1) % 7;
    for (int i = cities[r].b - 1; i >= cities[l].b + 1; i--) {
        prof = max(prof, blocks2[d][i].maxx - minn);
        minn = min(minn, blocks2[d][i].minn);
        prof = max(prof, blocks2[d][i].maxprofit);
        maxx = max(maxx, blocks2[d][i].maxx);
        d = (d + blocks2[d][i].rgt - blocks2[d][i].lft + 1) % 7;
    }
    if (cities[l].b != cities[r].b) {
        int ls = min(r, blocks2[0][cities[l].b].rgt);
        cal2(ls, l, d, maxx, minn, prof);
    }
    return prof;
}

int query(int l, int r) {
    int d = 0;
    int ls = min(r, blocks[0][cities[l].b].rgt);
    int maxx = 0, minn = 1e9, prof = 0;

    cal(l, ls, d, maxx, minn, prof);
    d = (d + ls - l + 1) % 7;
    for (int i = cities[l].b + 1; i <= cities[r].b - 1; i++) {
        prof = max(prof, blocks[d][i].maxx - minn);
        minn = min(minn, blocks[d][i].minn);
        prof = max(prof, blocks[d][i].maxprofit);
        maxx = max(maxx, blocks[d][i].maxx);
        d = (d + blocks[d][i].rgt - blocks[d][i].lft + 1) % 7;
    }
    if (cities[l].b != cities[r].b) {
        int rs = max(l, blocks[0][cities[r].b].lft);
        cal(rs, r, d, maxx, minn, prof);
    }
    return prof;
}

int main() {
#ifdef LOCALLL
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif
    scanf("%d", &n);
    B = (int)sqrt(n) + 1;
    int cnt = (n + B - 1) / B;
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &cities[i].v, &cities[i].d);
        cities[i].b = (i - 1) / B + 1;
    }
    for (int d = 0; d < 7; d++) {
        for (int i = 1; i <= cnt; i++) {
            // 确定块的左右边界
            blocks[d][i].lft = B * (i - 1) + 1;
            blocks[d][i].rgt = B * i;
            blocks2[d][i].lft = B * (i - 1) + 1;
            blocks2[d][i].rgt = B * i;
            int l = blocks[d][i].lft, r = blocks[d][i].rgt;
            Block& cur = blocks[d][i];
            cur.maxx = 0, cur.minn = 1e9, cur.maxprofit = 0;
            Block& cur2 = blocks2[d][i];
            cur2.maxx = 0, cur2.minn = 1e9, cur2.maxprofit = 0;
            cal(l, r, d, cur.maxx, cur.minn, cur.maxprofit);
            cal2(r, l, d, cur2.maxx, cur2.minn, cur2.maxprofit);
        }
    }
    scanf("%d", &m);
    while (m--) {
        int l, r;
        scanf("%d%d", &l, &r);
        if (l <= r) {
            printf("%d\n", query(l, r));
        } else {
            printf("%d\n", query2(l, r));
        }
    }
    return 0;
}