CF Equilibrium

CF Equilibrium

[link](Problem - E - Codeforces)

题意：

给定两个序列a，b，和一个操作：选择当前区间内的一个子序列保证子序列的长度为偶数，该子序列奇数位置ai+1，偶数位置bi+1。每次询问[l, r] 最少通过多少此操作使得当前区间内的每一个ai == bi，如果不可能输出-1。

题解：

首先子序列是只需要保证相对顺序，不必连续的。

设ci = bi - ai 那么问题就转化为使得区间内任意ci都为0，选择奇数位置等价于ci减一，偶数位置ci加一。也就是对c求一个前缀和sum，保证sumr - suml - 1大于零。

我们把减操作等价为左括号，把加操作等价为右括号，当前ci为正则需要左括号，为负则序号右括号。问题就巧妙转换为了一个括号匹配问题。

首先一定要左括号起手，所以对于查询的区间[l, r] 的左端点cl一定要大于零，否则就不成立。那么同理，如果有一个sum[x]- sum[l - 1] 是一个小于零的也不成立，因此要把当前区间变成0，需要的右括号一定大于左括号，那么一定无法匹配。

其次发现，左括号和右括号的数目一定要一样多，即sum[r] - sum[l - 1] == 0

如果有答案，因为是子序列，所以答案就取决于区间最大的一个前缀和，因为，其他的都可以在消除这些左括号的时候顺带消除掉，只有这个最长的前缀和左括号需要一点点独立操作。

因此用一个线段树来维护ci的一个前缀和数组sum

l, r区间

mn区间最小值

mx区间最大值

匹配成功后每次的答案就是 区间最大值。

Code

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <set>
#include <queue>
#include <vector>
#include <map>
#include <unordered_map>
#include <cmath> 
#include <stack>
#include <iomanip>
#include <deque> 
#include <sstream>
#define x first
#define y second
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
struct Node {
    int l, r;
    LL mn, mx;
}tr[N * 4];
LL a[N], b[N], c[N]; 
void build(int u, int l, int r) {
    if (l == r) tr[u] = {l, r, c[r], c[r]};
    else {
        tr[u] = {l, r}; 
        int mid = l + r >> 1;
        build (u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        tr[u].mx = max(tr[u << 1].mx, tr[u << 1 | 1].mx);
        tr[u].mn = min(tr[u << 1].mn, tr[u << 1 | 1].mn);
    }
}
LL query_mn(int u, int l, int r) {
    if (l <= tr[u].l && r >= tr[u].r ) return tr[u].mn;   
    int mid = tr[u].l + tr[u].r >> 1;
    LL res = 0x3f3f3f3f3f3f3f3f;
    if (l <= mid) res = min(res, query_mn(u << 1, l, r));
    if (r > mid)  res = min(res, query_mn(u << 1 | 1, l, r));
    return res;
}
LL query_mx(int u, int l, int r) {
    if (l <= tr[u].l && tr[u].r <= r) return tr[u].mx;
    int mid = tr[u].l + tr[u].r >> 1;
    LL res = -0x3f3f3f3f3f3f3f3f;
    if (l <= mid) res = max(res, query_mx(u << 1, l, r));
    if (r > mid)  res = max(res, query_mx(u << 1 | 1, l, r));
    return res;
}
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    for (int i = 1; i <= n; i ++ ) cin >> b[i];
    for (int i = 1; i <= n; i ++ ) c[i] += c[i - 1] + b[i] - a[i];
    build(1, 1, n);
    while (m --) {
        int l, r;
        cin >> l >> r;
        if (c[r] - c[l - 1] || query_mn(1, l, r) - c[l - 1] < 0) cout << -1 << endl;
        else cout << query_mx(1, l, r) - c[l - 1] << endl;
    }
return 0;
}