Codeforces Round #772 (Div. 2) 题解 （A-F）

1635A - Min Or Sum

题意：给定一个序列 $a$，每次可以将 $a_i$ 和 $a_j$ 替换成 $x$ 和 $y$，要求 $a_i\mid a_j=x\mid y$，问若干次操作后能达到的最小的序列和。

注意到将 $(a_i,a_j)\to (a_i\mid a_j,0)$ 是最优的做法，我们可以通过这样的操作，让尽可能多的数字等于 $0$，然后保留一个 $a_1\mid a_2\mid \cdots \mid a_n$。

所以 $a_1\mid a_2\mid \cdots \mid a_n$ 即为答案。

1635B - Avoid Local Maximums

题意：给定一个序列 $a$，每次可以将一个 $a_i$ 改成任意正整数 $x$，问最少多少次这样的操作后，整个序列不存在 local maximum，即不存在 $i$ 满足 $a_{i-1}<a_i>a_{i+1}$。$n=2\times 10^5$。

div2 B 题，考虑有没有什么贪心做法。

我们注意到，一次操作最多能够消除两个 local maximums，而且这两个 local maximum 一定相邻。

所以考虑如下贪心算法，从左往右扫，如果遇到一个 local maximum $a_i$，则将 $a_{i+1}\leftarrow \max (a_i,a_{i+2})$。不难发现这样最多就可以同时干掉两个 local maximum，因此其是最优的。

const int maxn = 2e5 + 5;
int a[maxn], n;

int main() {
    int T; read(T);
    while (T--) {
        read(n);
        FOR(i, 1, n) read(a[i]);
        int ans = 0;
        FOR(i, 2, n - 1)
            if (a[i] > a[i + 1] && a[i] > a[i - 1])
                a[i + 1] = max(a[i], a[i + 2]), ++ans;
        print(ans);
        FOR(i, 1, n) print(a[i], ' ');
        putchar('\n');
    }
    return output(), 0;
}

1635C - Differential Sorting

题意：给定一个序列 $a$，每次操作可以选择 $1\le x<y<z\le n$，然后 $a_x\leftarrow a_y-a_z$，构造一个方案使得整个序列不降。$n=2\times 10^5$。

我们注意到，选择的三个下标一定要满足 $x<y<z$，所以发现第一个性质：若 $a_{n-1}>a_n$，则无解，因为我们没办法修正 $a_n-1$。接下来，我们注意到，若 $a_n\ge 0$，则我们可以将前面所有数字修正为 $a_{n-1}-a_n$。否则无解，除非序列一开始就不降。

证明：假设 $a_n<0$ 且序列初始不满足不降，并且我们用了 $m$ 步完成排序。假设我们最后一步操作是 $(x_m,y_m,z_m)$，不难发现为了保证不降，所有元素都是负值，故 $a_{z_m}$ 一定 $<0$，但是 $a_{x_m}=a_{y_m}-a_{z_m}>a_{y_m}$，假设不成立。

const int maxn = 2e5 + 5;
int a[maxn], n;

int main() {
    int T; read(T);
    while (T--) {
        read(n);
        FOR(i, 1, n) read(a[i]);
        if (is_sorted(a + 1, a + n + 1)) {
            print(0);
            continue;
        }
        if (a[n - 1] > a[n] || a[n] < 0) {
            print(-1);
            continue;
        }
        print(n - 2);
        FOR(i, 1, n - 2) print(i, n - 1, n);
    }
    return output(), 0;
}

1635D - Infinite Set

题意：给定一个序列 $a_{1\cdots n}$，令集合 $S$ 如下构造：

• $\forall i$，$a_i\in S$。
• $\forall x\in S$，$2x+1\in S$。
• $\forall x\in S$，$4x\in S$。

问集合 $S$ 中严格小于 $2^p$ 的元素个数，答案对 $10^9+7$ 取模，$n,p\le 2\times 10^5$。

发现 $p$ 很大，且 $2x+1$ 和 $4x$ 这样的操作让人联想到位运算。所以先在二进制下考虑这个问题的 $n=1$ 版本。

发现，每次做插入 $2x+1$ 和插入 $4x$ 这样构成了一个决策树，得到的答案绝对不会相交。而 $2x+1$ 相当于将 $x$ 左移一位再将最后一位设成 $1$，$4x$ 相当于将 $x$ 左移两位。所以我们实际上就是将 $x$ 往左移一定的位数，保证最高位 $ < p$ 即可。

统计一下这样的方案数：不难发现设 $f_i$ 为左移 $i$ 位能得到的数字个数，有
$$\{\begin{array}{ll}{f}_1=1& \\ f_2=2& \\ f_i=f_{i-1}+f_{i-2}+1& i\ge 3\end{array}$$
于是 $n=1$ 的情况就考虑完了。对于原来那种“从数集”扩展的模式，最麻烦的就是 $a_i$ 能变换到 $a_j$，这样子方案数就会算重。所以考虑去重。发现从决策树的节点往根跳的过程很容易（因为最后一步是确定的），所以对于每个 $a_i$，都这样往回跳跳，如果跳到了某个 $a_j$，就直接不用考虑 $a_i$ 即可。

于是本题得到了解决。

const int maxn = 2e5 + 5;
int n, p, a[maxn];
modint f[maxn];
std::set<int> S;

int main() {
    read(n, p);
    f[p] = 1;
    DEC(i, p - 1, 1) f[i] = f[i + 1] + f[i + 2] + 1;
    FOR(i, 1, n) read(a[i]), S.insert(a[i]);
    modint ans = 0;
    DEC(i, n, 1) {
        bool flg = 1;
        int x = a[i];
        while (x) {
            if (x & 1) x >>= 1;
            else if (x % 4) break;
            else x >>= 2;
            if (S.count(x)) {
                flg = 0;
                break;
            }
        }
        if (flg) {
            int highbit = 0;
            DEC(j, 30, 0) if ((1 << j) & a[i]) {
                highbit = j;
                break;
            }
            ans += f[highbit + 1];
        }
    }
    print(ans);
    return output(), 0;
}

1635E - Cars

一维数轴上，初始在 $n$ 个不同位置有 $n$ 辆车，车的朝向确定，而速度可以为任意常数。定义两种车子之间的关系：

• 称两辆车风马牛不相及当且仅当不论他们的速度如何，他们都永远无法相遇。
• 称两辆车双向奔赴命中注定当且仅当不论他们的速度如何，他们都能在一个点相遇。

现在给定 $m$ 条这样的关系，请还原出 $n$ 辆车的坐标和朝向。$n,m\le 2\times 10^5$。

首先不难发现，“风马牛不相及”指的就是两辆车是往两边散开的，“双向奔赴命中注定”指的就是两辆车是往中间双向奔赴的。有关系的车的朝向都是不一样的，这个可以用二分图染色染一下。

然后，对于风马牛不相及的车的关系，可以发现 $x_L<x_R$，相应的对于双向奔赴的，有 $x_R<x_L$，于是我们可以考虑给原来二分图的边定向：若 $x_u<x_v$，则连边 $u\to v$，反之亦然。

这样下来，发现这些约束关系合法当且仅当图是张 DAG，并且需要求方案的话输出拓扑序就可以了。所以总结一下算法流程：二分图染色（判断无解），给边定向，拓扑排序（判断无解）。

const int maxn = 2e5 + 5;
vector<int> G0[maxn], G[maxn];
int n, m, vis[maxn], col[maxn], ind[maxn], x[maxn];
bool flg = 1;

struct Relation {
    int op, u, v;
} a[maxn];

void dfs(int u, int cur) {
    col[u] = cur, vis[u] = 1;
    for (int &v : G0[u]) {
        if (vis[v] && col[v] == cur) flg = 0;
        if (vis[v]) continue;
        dfs(v, cur == 1 ? 2 : 1);
    }
}

int main() {
    read(n, m);
    FOR(i, 1, m) read(a[i].op, a[i].u, a[i].v), G0[a[i].u].push_back(a[i].v), G0[a[i].v].push_back(a[i].u);
    FOR(i, 1, n) if (!vis[i]) dfs(i, 1);
    if (!flg) {
        print("NO");
    } else {
        FOR(i, 1, m) {
            const int &u = a[i].u, &v = a[i].v;
            if (a[i].op == 1) {
                if (col[u] == 1) G[u].push_back(v), ++ind[v];
                else G[v].push_back(u), ++ind[u];
            } else {
                if (col[u] == 2) G[u].push_back(v), ++ind[v];
                else G[v].push_back(u), ++ind[u];
            }
        }
        queue<int> q;
        FOR(i, 1, n) if (!ind[i]) q.push(i);
        int cntx = 0;
        while (!q.empty()) {
            int u = q.front();
            x[u] = ++cntx;
            q.pop();
            for (const int &v : G[u]) {
                if (!--ind[v]) q.push(v);
            }
        }
        if (cntx != n) {
            print("NO");
        } else {
            print("YES");
            FOR(i, 1, n) {
                putchar(col[i] == 1 ? 'L' : 'R'); putchar(' ');
                print(x[i]);
            }
        }
    }
    return output(), 0;
}

1635F - Closest Pair

$n$ 个二元组 $(x_i,w_i)$，$|x_i|,w_i\le 10^9$，$n\le 3\times 10^5$，$x_i$ 升序。$q\le 3\times 10^5$ 次询问，给出 $[l,r]$，求

$$\underset{l\le i<j\le r}{\min }|x_i-x_j|(w_i+w_j)$$

数据结构结论题。

考虑哪些 $(i,j)$ 是不优的。

• 若存在 $p$ 和 $q$，使得 $x_p<x_q\wedge w_p>w_q$，则 $q$ 作为 $i$ 一定比 $p$ 优。
• 若存在 $p$ 和 $q$，使得 $x_p<x_q\wedge w_p<w_q$，则 $p$ 作为 $j$ 一定比 $q$ 优。

于是，令 L i = max ⁡ { j : j < i ∧ w j ≤ w i } L_i = \max\{j:j < i\land w_j\le w_i\} Li​=max{j:j<i∧wj​≤wi​}， R i = min ⁡ { j : j > i ∧ w j ≤ w i } R_i = \min\{j:j > i\land w_j\le w_i\} Ri​=min{j:j>i∧wj​≤wi​}，答案就只能取形如 $[i,R_i]$ 或 $[L_i,i]$ 的区间。这样的区间一共有 $2n$ 个。

先用单调栈求出所有的 $L_i$ 和 $R_i$，再计算出这 $2n$ 个区间 $[l_i,r_i]$ 的价值 $c_i$，在每个 $r_i$ 上挂上标记 $(l_i,c_i)$，在每个询问 $(i,ql,qr)$ 的 $qr$ 上挂上标记 $(ql,i)$。然后扫描线扫右端点，线段树或者树状数组维护一下 RMQ 和单点修改，这题就做完了。

using ll = long long;
using pll = pair<ll, ll>;
const int maxn = 3e5 + 5;
int n, m, L[maxn], R[maxn], stk[maxn], top;
ll t[maxn << 2], ans[maxn];
pll a[maxn];
vector<pll> op[maxn], q[maxn];

il ll calc(int i, int j) {return myabs(a[i].first - a[j].first) * (a[i].second + a[j].second);}

#define L (k << 1)
#define R (L | 1)
#define M ((i + j) >> 1)

void modify(int i, int j, int k, int x, ll v) {
    if (i == j) {
        chkmin(t[k], v);
        return;
    }
    if (x <= M) modify(i, M, L, x, v);
    else modify(M + 1, j, R, x, v);
    t[k] = min(t[L], t[R]);
    return;
}

ll query(int i, int j, int k, int x, int y) {
    if (x <= i && y >= j) return t[k];
    ll ret = 2e18;
    if (x <= M) chkmin(ret, query(i, M, L, x, y));
    if (y > M) chkmin(ret, query(M + 1, j, R, x, y));
    return ret;
}

#undef L
#undef R
#undef M

int main() {
    read(n, m);
    FOR(i, 1, n) read(a[i].first, a[i].second);
    FOR(i, 1, m) {
        int l, r; read(l, r);
        q[r].push_back({l, i});
    }
    FOR(i, 1, n) {
        while (top > 0 && a[stk[top]].second > a[i].second) --top;
        L[i] = stk[top], stk[++top] = i;
    }
    top = 0;
    DEC(i, n, 1) {
        while (top > 0 && a[stk[top]].second > a[i].second) --top;
        R[i] = stk[top], stk[++top] = i;
    }
    FOR(i, 1, n) {
        if (L[i]) op[i].push_back({L[i], calc(L[i], i)});
        if (R[i]) op[R[i]].push_back({i, calc(i, R[i])});
    }

    memset(t, 0x3f, sizeof t);
    FOR(i, 1, n) {
        for (auto &p : op[i]) modify(1, n, 1, p.first, p.second);
        for (auto &p : q[i]) ans[p.second] = query(1, n, 1, p.first, i);
    }
    FOR(i, 1, m) print(ans[i]);
    return output(), 0;
}