数据结构 专项题解
Hash
Long Long Message
解题报告
性质：如果存在一个长度为 len 的相同子串，那么一定存在一个长度为 len - 1 的相同子串
于是可以二分查找，通过哈希判断是否存在
代码实现
双模太慢过不去，小模数会被卡，只能自然溢出
typedef unsigned long long int lli;
const int MAXL = 1000000 + 10;
const int M1 = 1e9 + 7;
const int base = 131;
int powm1[MAXL];
int n, m;
char s1[MAXL], s2[MAXL];
std::vector<lli> hshs;
bool check(int mid) {
lli h1 = 0, pw = 1; hshs.clear();
for (int i = 1; i <= mid; ++i) {
h1 = (1ull * h1 * base + s1[i]);
pw = 1ull * pw * base;
} hshs.push_back(h1);
for (int i = mid + 1; i <= n; ++i) {
h1 = (1ull * h1 * base + s1[i] - 1ull * pw * s1[i - mid]);
hshs.push_back(h1);
} std::sort(ALL(hshs));
lli h2 = 0;
for (int i = 1; i <= mid; ++i) {
h2 = (1ull * h2 * base + s2[i]);
} if (std::binary_search(ALL(hshs), h2)) return true;
for (int i = mid + 1; i <= m; ++i) {
h2 = (1ull * h2 * base + s2[i] - 1ull * pw * s2[i - mid]);
if (std::binary_search(ALL(hshs), h2)) return true;
} return false;
}
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> (s1 + 1);
cin >> (s2 + 1);
n = (int) strlen(s1 + 1);
m = (int) strlen(s2 + 1);
int l = 0, r = std::min(n, m), ans = 0; // if a substr s[len] exists, a substr s[len - 1] exists
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid; l = mid + 1;
} else r = mid - 1;
} cout << ans << endl;
return 0;
}
比赛
解题报告
考虑爆搜，需要记录状态有：哪些队伍打完所有比赛了（通过按顺序搜索可以直接优化掉这一维），当前是哪两只队伍比赛，所有人的分数
考虑优化状态量，发现后面未确定的队伍成绩顺序调换，本质上是一个方案，所以实际上无需按顺序记录所有人的分数，只需要记录的分数集合，这样就消掉了一个 \(O(n!)\) 的状态量，记录的分数集合可以用 Hash 维护。
然后还需要加入一些其他剪枝。
代码实现
const int MAXN = 10 + 5;
const int base = 31;
const int HA = 1e9 + 7;
int n;
int scr[MAXN];
int stt[MAXN];
int cntwin, cntdraw;
std::map<ulli, int> mp;
ulli Hash(int n1) {
static int tmp[MAXN];
for (int i = n1 + 1; i <= n; ++i) tmp[i] = scr[i] - stt[i];
std::sort(tmp + n1 + 1, tmp + 1 + n, std::greater<int>());
ulli h1 = 0; for (int i = n1 + 1; i <= n; ++i) h1 = 1ull * h1 * base + tmp[i] + 1;
return h1;
}
int search(int n1, int n2) {
if (n1 == n) return 1; // recursive exit
if (stt[n1] + (n - n2 + 1) * 3 < scr[n1]) return 0;
if (n2 == n + 1) {
// n1 已经比完赛了
ulli hashStt = Hash(n1);
if (mp.count(hashStt)) return mp[hashStt];
return mp[hashStt] = search(n1 + 1, n1 + 2);
} int res = 0;
if (stt[n1] + 3 <= scr[n1] && cntwin) {
--cntwin; stt[n1] += 3; res += search(n1, n2 + 1);
++cntwin; stt[n1] -= 3;
}
if (stt[n2] + 3 <= scr[n2] && cntwin) {
--cntwin; stt[n2] += 3; res += search(n1, n2 + 1);
++cntwin; stt[n2] -= 3;
}
if (stt[n1] + 1 <= scr[n1] && stt[n2] + 1 <= scr[n2] && cntdraw) {
--cntdraw; ++stt[n1]; ++stt[n2]; res += search(n1, n2 + 1);
++cntdraw; --stt[n1]; --stt[n2];
} return res % HA;
}
int main() {
n = read(); int sum = 0;
for (int i = 1; i <= n; ++i) { sum += (scr[i] = read()); }
std::sort(scr + 1, scr + 1 + n);
cntwin = sum - n * (n - 1);
cntdraw = (sum - cntwin * 3) >> 1;
printf("%d\n", search(1, 2));
return 0;
}
堆
KLO - Building Blocks
解题报告
很容易能想到将一段连续的砖高度改成中位数是最优的，所以题目就转化成了一个类似滑动窗口的东西，求区间中位数
问题是时间戳没法处理，毕竟堆只能删除堆顶元素。
所以这里使用 std::multiset 维护。
代码实现
const int MAXN = 1000000 + 10;
#define int lli
int n, k, mxh;
int aa[MAXN], psum[MAXN];
int opm = 0x7f7f7f7f7f7f7f7f, opl, opr, opmed;
std::multiset<int> lft, rgt; // [lft x][ rgt ]
int lsum, rsum;
int MED() { return *lft.rbegin(); }
void Balance() {
while (lft.size() > rgt.size() + 1) {
rgt.insert(*lft.rbegin()); rsum += *lft.rbegin();
lsum -= *lft.rbegin(); lft.erase(lft.find(*lft.rbegin()));
} while (lft.size() < rgt.size() + 1) {
lft.insert(*rgt.begin()); lsum += *rgt.begin();
rsum -= *rgt.begin(); rgt.erase(rgt.find(*rgt.begin()));
}
}
void Insert(int pos) {
if (lft.empty() || pos <= MED()) { lft.insert(pos); lsum += pos; }
else { rgt.insert(pos); rsum += pos; }
Balance();
}
void Delete(int pos) {
if (pos <= MED()) {
auto it = lft.find(pos); lft.erase(it); lsum -= pos;
} else {
auto it = rgt.find(pos); rgt.erase(it); rsum -= pos;
}
Balance();
}
void Solve(int l, int r) {
int med = *lft.rbegin();
int leftsiz = lft.size();
int rightsiz = rgt.size();
int leftsum = lsum;
int rightsum = rsum;
int cost = rightsum - med * rightsiz + med * leftsiz - leftsum;
if (cost < opm) {
opm = cost; opl = l; opr = r; opmed = med;
}
}
signed main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> aa[i]; psum[i] = psum[i - 1] + aa[i];
mxh = std::max(mxh, aa[i]);
}
for (int i = 1; i <= k; ++i) {
Insert(aa[i]);
} Solve(1, k);
for (int i = k + 1; i <= n; ++i) {
Delete(aa[i - k]);
Insert(aa[i]);
Solve(i - k + 1, i);
}
cout << opm << endl;
for (int i = 1; i <= opl - 1; ++i) {
cout << aa[i] << endl;
} for (int i = opl; i <= opr; ++i) {
cout << opmed << endl;
} for (int i = opr + 1; i <= n; ++i) {
cout << aa[i] << endl;
}
return 0;
}
std::set （算数据结构吗？
CF392D Three Arrays
解题报告
首先，我们只能枚举一个数组用多少数，且必须在 \(O(\log^2 n),O(\log n)\) 或更短时间内求出另外两个数组的答案。
先对每一个数进行一个转换：设数对 \(t_i\rightarrow (x_i, y_i, z_i)\) 的三个参数分别表示 \(t_i\) 这个数在 \(a_i,b_i,c_i\) 中第一次出现的位置（不存在就是无穷大），那么一个合法的方案 \((u, v, w)\) 即满足 \(\forall t_i,a_i \leq u \text{ or } b_i \leq v \text{ or } c_i \leq w\)。
既然我们已经枚举了第一维的 \(u\)，那么通过对数对的第一维进行排序（毕竟我们不关心每个数字的具体大小，我们只关心每个数对有没有满足条件，所以排序完全没有问题），我们可以快速得出哪些数是已经满足条件的，而哪些数没有满足条件。接下来就是对剩下不满足条件的数对（以下均称“数对”）进行求解。
忽略第一维后，考虑将数对看作二维平面上的点 \((X_i,Y_i)\)（字母大写和上面的数对定义做区分），那么问题就转化成了求两条直线 \(x = v, y = w\)，满足：所有点要么在 \(x = v\) 的左边、要么在 \(y = w\) 的下面。
也就是把第一象限再划分成四个小块，让每个点都不在右上方的小块（可以在边界上）。
图中的当然不是最优方案。（可能的）最优方案一定要满足，固定一条线后，另一条线下降到不能再下降。因为坐标轴可以旋转，所以这里一律固定 \(x = v\) 并让 \(y = w\) 尽可能下降。也就是这样：
（细心的同学可以发现这张图其实是重画了的，大家尽量理解一下）
通俗地说，选定两个相邻的“最外层”的点（类似于一个凸包），以左边点的横坐标作为 \(v\)，以右边点的纵坐标作为 \(w\)，这样选出来的直线 \(x = v,y = w\) 才有可能成为一个最优的方案，该方案的答案就是 \(v + w\)。
下一个方案、再下一个方案是这样的：
可以看到，它是一个“阶梯型”下降的趋势。这个阶梯图样非常重要，是本题解题关键。
刚刚说到了对第一维进行排序，排完序之后不满足的点就可以一个一个加入这个二维平面，寻找一个能让它满足的方案。一个点加入后就不能删除，那么有些点永远也无法成为“最外层”的点，让我们直接忽略它们！
接下来你有了一堆纵坐标递减的点。这些点能产生的所有答案就是相邻的 \(X_i +Y_{i + 1}\)，到时候更新答案即是求它的最小值。考虑加入一个新点会对它们有什么影响。
此时加入一个新点：
首先，D 和 E 组成的答案无法满足 J 的条件，这个答案应当被删除。
其次，B、C、D 三个点不再是“最外层”的点，应当把它们和它们产生的答案从图中删去。此时我们也可以看出，一个点是“最外层的点”的充要条件是：不存在横纵坐标都比它大的点。
在做完上述两个处理之后，我们就可以放心添加 \(X_A +Y_J, X_J+Y_E\) 这两个答案了。
所以，加入一个新点，应当先删除相邻节点不合法的答案，再循环删除所有不在最外层的点，最后再计算它与相邻点产生的答案。
维护这个二维平面的点需要快速插入、查找、删除（按一定顺序的）相邻节点；维护这个二维平面上所有的答案需要快速插入、查找、删除，查询最小值。
这几个操作只需要 std::set 和 std::multiset 即可完成。
代码实现
const int MAXN = 1e5 + 10;
int n; int aa[4][MAXN];
struct ND {
int val, pos, from;
bool operator < (const ND &th) const {
return val < th.val;
}
bool operator == (const ND &th) const {
return val == th.val && pos == th.pos && from == th.from;
}
} nds[MAXN * 3];
struct POS {
int from[4];
POS() { from[0] = from[1] = from[2] = from[3] = 0x3f3f3f3f; }
bool operator < (const POS &th) const {
return from[1] > th.from[1];
}
} whereis[MAXN]; int cnt;
struct Point {
int x, y;
bool operator < (const Point &th) const {
return x == th.x ? y < th.y : x < th.x;
}
bool operator == (const Point &th) const {
return x == th.x && y == th.y;
}
}; std::set<Point> pts; std::multiset<int> sums;
// pts: store Points on the Ladder
void Insert(POS in) {
Point now = {in.from[2], in.from[3]};
pts.insert(now);
auto it_now = pts.find(now);
auto it_next = it_now; ++it_next;
if (it_next->x >= it_now->x && it_next->y >= it_now->y) {
pts.erase(now); return; // not on the Ladder
} auto it_prev = it_now; --it_prev;
if (sums.find(it_prev->x + it_next->y) != sums.end()) {
sums.erase(sums.find(it_prev->x + it_next->y));
} // remove an illegal sol which cannot contain the Point just added
while (true) {
// remove all Points which will be contained by the new Ladder
it_now = pts.find(now);
it_prev = it_now; --it_prev;
auto it_cprv = it_prev; --it_cprv;
if (!(it_prev->x <= it_now->x && it_prev->y <= it_now->y)) break;
if (sums.find(it_cprv->x + it_prev->y) != sums.end())
sums.erase(sums.find(it_cprv->x + it_prev->y));
pts.erase(it_prev);
} it_now = pts.find(now); // insert the new sol
it_next = it_now; ++it_next;
it_prev = it_now; --it_prev;
sums.insert(it_now->y + it_prev->x);
sums.insert(it_now->x + it_next->y);
}
void solve() {
std::sort(whereis + 1, whereis + 1 + cnt);
pts.insert({0, 0x3f3f3f3f + 2}); pts.insert({0x3f3f3f3f + 2, 0}); // placeholder
sums.insert(0); // placeholder
int ans = 0x3f3f3f3f;
for (int fst = n, now = 1; fst >= 0; --fst) {
while (now <= cnt && whereis[now].from[1] > fst) { // whereis[] is sorted in <from[1]>-decreasing order
// add nums which cannot be covered by [1]
Insert(whereis[now++]);
} ans = std::min(ans, *sums.begin() + fst);
} cout << ans << endl;
}
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n;
rep (t, 1, 3) {
rep (i, 1, n) { cin >> aa[t][i]; nds[i + (t - 1) * n] = {aa[t][i], i, t}; }
}
std::sort(nds + 1, nds + 1 + n * 3);
for (int i = 1; i <= 3 * n; ++i) { // sort, unique and record the first pos the num exists
if (nds[i].val != nds[i - 1].val) ++cnt;
aa[nds[i].from][nds[i].pos] = cnt;
whereis[cnt].from[nds[i].from] = std::min(whereis[cnt].from[nds[i].from], nds[i].pos);
}
solve();
return 0;
}
P2894 [USACO08FEB]Hotel G
解题报告
01 线段树，维护区间最长空白。一个空白可能在左边、中间、右边，所以要另外维护前缀、后缀空白长度。
代码实现
const int MAXN = 50000 + 10;
namespace SegT {
int maxe[MAXN << 2], pref[MAXN << 2], suff[MAXN << 2];
int tag[MAXN << 2];
#define ls (p << 1)
#define rs (p << 1 | 1)
void Update(int p, int l, int r) {
maxe[p] = std::max(maxe[ls], std::max(maxe[rs], suff[ls] + pref[rs]));
int mid = (l + r) >> 1;
pref[p] = pref[ls]; if (pref[ls] == mid - l + 1) pref[p] += pref[rs];
suff[p] = suff[rs]; if (suff[rs] == r - mid) suff[p] += suff[ls];
}
void build(int p, int l, int r) {
tag[p] = -1;
if (l == r) { maxe[p] = suff[p] = pref[p] = 1; return; }
int mid = (l + r) >> 1;
build(ls, l, mid); build(rs, mid + 1, r);
Update(p, l, r);
}
void Mod(int p, int l, int r, int k) {
if (k == 0) maxe[p] = pref[p] = suff[p] = r - l + 1;
if (k == 1) maxe[p] = pref[p] = suff[p] = 0;
}
void Pushdown(int p, int l, int r) {
if (tag[p] == -1) return;
int mid = (l + r) >> 1;
Mod(ls, l, mid, tag[p]); Mod(rs, mid + 1, r, tag[p]);
tag[ls] = tag[rs] = tag[p];
tag[p] = -1;
}
int Checkin(int p, int l, int r, int len) {
if (maxe[p] < len) return 0;
if (maxe[p] == r - l + 1) return l;
Pushdown(p, l, r);
int mid = (l + r) >> 1;
// leftside
if (maxe[ls] >= len) return Checkin(ls, l, mid, len);
// cross mid
else if (suff[ls] && suff[ls] + pref[rs] >= len) return mid - suff[ls] + 1;
else return Checkin(rs, mid + 1, r, len);
}
void Modify(int p, int l, int r, int ll, int rr, int k) {
if (l == ll && rr == r) { Mod(p, l, r, k); tag[p] = k; return; }
Pushdown(p, l, r);
int mid = (l + r) >> 1;
if (rr <= mid) Modify(ls, l, mid, ll, rr, k);
else if (mid + 1 <= ll) Modify(rs, mid + 1, r, ll, rr, k);
else { Modify(ls, l, mid, ll, mid, k); Modify(rs, mid + 1, r, mid + 1, rr, k); }
Update(p, l, r);
}
}
int n, m;
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> m; SegT::build(1, 1, n);
while (m --> 0) {
int op, x; cin >> op >> x;
if (op == 1) {
int ln = SegT::Checkin(1, 1, n, x);
cout << ln << endl;
if (ln) SegT::Modify(1, 1, n, ln, ln + x - 1, 1);
} else {
int y; cin >> y;
SegT::Modify(1, 1, n, x, x + y - 1, 0);
}
}
return 0;
}
CF703D Mishka and Interesting sum
解题报告
正着求不好求，但是出现奇数次的数异或和很好求，所以就反着求，再求一个区间所有不同数异或和，然后俩异或一下就是答案。
发现直接维护区间不好维护，于是选择离线做法，按右端点排序询问，然后维护前缀不同数异或和 \(t_i\)、前缀所有数异或和（其实就是“出现奇数次的数异或和”）\(w_i\)，于是答案就是 \(t_r \oplus t_{l - 1}\oplus w_r \oplus w_{l - 1}\)。
每向右移动一次当前的右端点，就是要加入这个数；但是这个数可能在之前出现过，这样再搞一个前缀异或就会把这个数消掉，于是我们要在之前它出现的位置先删掉这个数，再在这个位置加入。
为什么不干脆就不加入了呢？因为 \(t_r \oplus t_{l - 1}\) 的时候，会把所有位置在 \([1, l - 1]\) 的不同数消掉，包括以前出现的那个数。所以这里只能这么搞。
代码实现
所以我选择了树状数组。
const int MAXN = 1000000 + 10;
int n, m;
int aa[MAXN], bb[MAXN]; int lisan[MAXN];
int last[MAXN], prev[MAXN], prefxor[MAXN];
struct Q { int l, r, id; } qrys[MAXN]; int ans[MAXN];
bool cmp(Q x, Q y) { return x.r < y.r; }
namespace BIT {
int ss[MAXN];
#define lb(x) ((x) & (-(x)))
void insert(int pos, int x) {
for (; pos <= n; pos += lb(pos)) ss[pos] ^= x;
}
int qry(int pos) {
int r = 0; for (; pos >= 1; pos -= lb(pos)) r ^= ss[pos];
return r;
}
}
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) { cin >> aa[i]; lisan[i] = aa[i]; }
cin >> m;
for (int i = 1; i <= m; ++i) { cin >> qrys[i].l >> qrys[i].r; qrys[i].id = i; }
std::sort(qrys + 1, qrys + 1 + m, cmp);
std::sort(lisan + 1, lisan + 1 + n); int tot = std::unique(lisan + 1, lisan + 1 + n) - lisan - 1;
rep (i, 1, n) bb[i] = std::lower_bound(lisan + 1, lisan + 1 + tot, aa[i]) - lisan;
rep (i, 1, n) {
prev[i] = last[bb[i]];
last[bb[i]] = i;
prefxor[i] = prefxor[i - 1] ^ aa[i];
}
int tr = 0;
rep (i, 1, m) {
while (tr < qrys[i].r) {
++tr;
if (prev[tr]) BIT::insert(prev[tr], aa[tr]); // 删除以前的
BIT::insert(tr, aa[tr]); // 加入现在的
}
ans[qrys[i].id] = (BIT::qry(qrys[i].r) ^ BIT::qry(qrys[i].l - 1)) ^ (prefxor[qrys[i].r] ^ prefxor[qrys[i].l - 1]);
}
rep (i, 1, m) cout << ans[i] << endl;
return 0;
}
当然也可以直接莫队搞过去，不过需要玄学卡常
const int MAXN = 1000000 + 10;
int n, m;
int aa[MAXN], fa[MAXN];
int blksiz, bel[MAXN];
int lisan[MAXN];
struct QS { int l, r, id; } qs[MAXN]; int ans[MAXN];
bool cmp(QS x, QS y) {
return bel[x.l] == bel[y.l] ? (bel[x.l] & 1 ? x.r < y.r : x.r > y.r) : bel[x.l] < bel[y.l];
}
int indxor, allxor;
int exist[MAXN];
void Add(int x) {
if (!exist[fa[x]]) indxor ^= aa[x];
++exist[fa[x]];
allxor ^= aa[x];
}
void Del(int x) {
--exist[fa[x]];
if (!exist[fa[x]]) indxor ^= aa[x];
allxor ^= aa[x];
}
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
// Input
cin >> n;
rep (i, 1, n) { cin >> aa[i]; lisan[i] = aa[i]; }
std::sort(lisan + 1, lisan + 1 + n); int tot = std::unique(lisan + 1, lisan + 1 + n) - lisan - 1;
rep (i, 1, n) {
fa[i] = std::lower_bound(lisan + 1, lisan + 1 + tot, aa[i]) - lisan;
}
cin >> m;
rep (i, 1, m) {
cin >> qs[i].l >> qs[i].r; qs[i].id = i;
}
// Divide Blocks
blksiz = n / std::pow(m, 0.455);
rep (i, 1, n) bel[i] = (i - 1) / blksiz + 1;
std::sort(qs + 1, qs + 1 + m, cmp);
// Process Queries
int tl = 1, tr = 0;
rep (i, 1, m) {
while (tl > qs[i].l) Add(--tl);
while (tr < qs[i].r) Add(++tr);
while (tl < qs[i].l) Del(tl++);
while (tr > qs[i].r) Del(tr--);
ans[qs[i].id] = allxor ^ indxor;
}
rep (i, 1, m) cout << ans[i] << endl;
return 0;
}
CF413E Maze 2D
解题报告
先想想只用线段树的区间查询能不能做，此时线段树维护的就是两点间的最短距离。
好像不大好想？线段树是维护区间问题的，所以这里我们把两个节点所在的列看作区间边界，所以线段树维护的信息就是每个区间从一个边界到另一个边界的最短距离。
一个边界是两个格子，两个边界之间会有四个距离，所以我们一个区间要维护四个信息，即：左上 / 左下角的格子 到 右上 / 右下角的格子 的最短距离。如果不能到达就是 -1.
听起来好像挺对的？此时一个区间的答案可以被拆成多个区间的答案合并。
思考如何合并答案。
从左区间往右走，必然要从左区间左边界走到左区间右边界，经过交界处再花费 1 的距离从左区间右边界走到右区间左边界，再从右区间左边界走到右区间右边界。
如下图：
左区间左边界有两个起点，交界处有两个中继点，右区间右边界有两个终点，一共 8 种情况分别转移即可。
代码实现
dist 数组的第一维代表区间左边界的点，第二维代表区间右边界的点，0 是上边，1 是下边，dist[0][1] 即是从左上角往右下角走的最短路径长度。
const int MAXN = 2e5 + 10;
int n, m;
char ups[MAXN], dws[MAXN];
int valid(int pos, int k) {
if (k == 0) return ups[pos] == '.' ? 0 : -1;
return dws[pos] == '.' ? 0 : -1;
}
namespace SegTree {
struct Node { int dist[2][2]; Node() { memset(dist, -1, sizeof dist); } };
Node segt[MAXN << 2]; // LU -> RU, LU -> RD, LD -> RU, LD -> RD [L:U/D][R:U/D]
#define ls (p << 1)
#define rs (p << 1 | 1)
Node Merge(Node pl, Node pr) {
Node ret;
for (int stl = 0; stl < 2; ++stl) {
for (int edl = 0; edl < 2; ++edl) {
if (pl.dist[stl][edl] == -1) continue;
for (int edr = 0; edr < 2; ++edr) {
if (pr.dist[edl][edr] == -1) continue;
if (ret.dist[stl][edr] == -1)
ret.dist[stl][edr] = pl.dist[stl][edl] + 1 + pr.dist[edl][edr];
else ret.dist[stl][edr] = std::min(ret.dist[stl][edr], pl.dist[stl][edl] + 1 + pr.dist[edl][edr]);
}
}
}
return ret;
}
void Update(int p) {
segt[p] = Merge(segt[ls], segt[rs]);
}
void buildTree(int p, int l, int r) {
if (l == r) {
segt[p].dist[0][0] = valid(l, 0); segt[p].dist[1][1] = valid(l, 1);
segt[p].dist[0][1] = segt[p].dist[1][0] =
((valid(l, 0) != -1) && (valid(l, 1) != -1) ? 1 : -1);
return;
} int mid = (l + r) >> 1;
buildTree(ls, l, mid); buildTree(rs, mid + 1, r);
Update(p);
}
Node Query(int p, int l, int r, int ll, int rr) {
if (l == ll && rr == r) return segt[p];
int mid = (l + r) >> 1;
if (rr <= mid) return Query(ls, l, mid, ll, rr);
else if (mid + 1 <= ll) return Query(rs, mid + 1, r, ll, rr);
else return Merge(Query(ls, l, mid, ll, mid), Query(rs, mid + 1, r, mid + 1, rr));
}
}
int main() {
std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> m;
cin >> (ups + 1);
cin >> (dws + 1);
SegTree::buildTree(1, 1, n);
while (m --> 0) {
int u, v; cin >> u >> v;
int fx = (u - 1) % n + 1, fy = (v - 1) % n + 1;
int gx = (u - 1) / n, gy = (v - 1) / n;
if (fx > fy) { std::swap(fx, fy); std::swap(gx, gy); }
SegTree::Node ans = SegTree::Query(1, 1, n, fx, fy);
cout << ans.dist[gx][gy] << endl;
}
return 0;
}
