2025牛客国庆集训派对day7 M C 个人题解

Water

#exgcd #数学

题目翻译

Walk Alone 感到口渴，想要喝水。他想要恰好喝 x x x 单位的水，但没有合适的量杯。他只有两个水壶，容量分别为 A A A 和 B B B。他发现可以对这两个水壶进行以下操作：

将其中一个水壶装满水。
将其中一个水壶中的水全部倒掉。
喝掉其中一个水壶中的全部水。
尽可能多地将水从一个水壶转移到另一个水壶，且不能溢出。形式化地说，如果两个水壶当前分别含有 a a a 和 b b b 单位的水，则他可以从 A A A 向 B B B 转移 min ⁡ ( a , B − b ) \min(a, B - b) min(a,B−b) 单位的水，或者从 B B B 向 A A A 转移 min ⁡ ( b , A − a ) \min(b, A - a) min(b,A−a) 单位的水。

Walk Alone 希望尽可能少地操作。你能告诉他为了喝到恰好 x x x 单位的水所需的最少操作次数吗？

输入描述

输入包含多个测试用例。

第一行包含一个整数 T T T，表示测试用例的数量。

每个测试用例仅有一行，包含三个整数 A A A、 B B B 和 x x x，分别表示两个水壶的容量以及他需要喝的水的体积。

输出描述

对于每个测试用例，输出一行一个整数，表示最少操作次数。如果无法喝到恰好 x x x 单位的水，输出 − 1 -1 −1。

思路

所有的倒水操作实际上可以转化为：
A x + B y = C Ax+By=C Ax+By=C

其中 C C C为需要构造的数字
x , y ∈ Z x,y\in Z x,y∈Z

对于一次 x ± 1 x\pm 1 x±1，实际上需要两次操作

所以答案可以分类讨论：

当 x ≥ 0 & & y ≥ 0 x\geq 0\&\&y\geq 0 x≥0&&y≥0， a n s = 2 ( ∣ x ∣ + ∣ y ∣ ) m i n ans=2(|x|+|y|)_{min} ans=2(∣x∣+∣y∣)min
否则 a n s = 2 ( ∣ x ∣ + ∣ y ∣ ) m i n − 1 ans=2(|x|+|y|)_{min}-1 ans=2(∣x∣+∣y∣)min−1
- 这是由于 x ⋅ y < 0 x\cdot y<0 x⋅y<0，则可以少进行操作一次

对于方程 A x + B y = g c d ( A , B ) Ax+By=gcd(A,B) Ax+By=gcd(A,B)，可以通过 e x g c d exgcd exgcd解得特解 x 0 , y 0 x_{0},y_{0} x0,y0

由此可以获得通解：
{ x = x 0 + k ⋅ B g c d ( A , B ) y = y 0 − k ⋅ A g c d ( A , B ) \begin{cases} x=x_{0}+k\cdot \frac{B}{gcd(A,B)}\\ \\ y=y_{0}-k\cdot \frac{A}{gcd(A,B)} \end{cases} ⎩ ⎨ ⎧x=x0+k⋅gcd(A,B)By=y0−k⋅gcd(A,B)A

也就是说，答案变成了关于 k k k的函数：
f ( k ) = ∣ x ∣ + ∣ y ∣ = ∣ x 0 + k ⋅ B g c d ( A , B ) ∣ + ∣ y 0 − k ⋅ A g c d ( A , B ) ∣ f(k)=|x|+|y|=|x_{0}+k\cdot \frac{B}{gcd(A,B)}|+|y_{0}-k\cdot \frac{A}{gcd(A,B)}| f(k)=∣x∣+∣y∣=∣x0+k⋅gcd(A,B)B∣+∣y0−k⋅gcd(A,B)A∣

这是一个形如 f ( k ) = ∣ a k + b ∣ + ∣ c k + d ∣ f(k)=|ak+b|+|ck+d| f(k)=∣ak+b∣+∣ck+d∣的绝对值函数，其最小值必然在 ∣ a k 0 + b ∣ = ∣ c k 0 + d ∣ |ak_{0}+b|=|ck_{0}+d| ∣ak0+b∣=∣ck0+d∣时取到，但由于 k ∈ Z k\in Z k∈Z，所以可能在 ⌊ k 0 ⌋ , ⌈ k 0 ⌉ \lfloor k_{0} \rfloor,\lceil k_{0} \rceil ⌊k0⌋,⌈k0⌉处取得

因此，记录所有可能的 k k k值，遍历一遍取最小的答案即可

代码

cpp 复制代码

#include<iostream>
#include<vector>
#include<unordered_map>
#include<map>
#include<unordered_set>
#include<set>
#include<algorithm>
#include<cmath>

using namespace std;
const double eps = 1e-6;
#define ll long long
#define int ll
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define see(stl) for(auto&ele:stl)cout<<ele<<" ";cout<<'\n';
#pragma GCC optimize(3, "Ofast", "inline")

const int inf = 2e14;

constexpr int exgcd(int a, int b, int& x, int& y) {
    if (!b) {
        x = 1, y = 0;return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}

void solve() {
    int A, B, C;cin >> A >> B >> C;
    int g = __gcd(A, B);
    if (C % g != 0) {
        cout << -1 << '\n';return;
    }
    vector<int>v = { (int)ceil(1.0 * C / (A + 1)),(int)floor(1.0 * C / (A + 1)),(int)ceil(1.0 * C / (A - 1)),(int)floor(1.0 * C / (A - 1)) };
    int ans = inf;
    for (int ele : v) {
        rep(d, 0, 10) {
            int x = ele - 5 + d;
            if ((-A * x + C) % B != 0)continue;
            int y = (-A * x + C) / B;
            if (x >= 0 && y >= 0)ans = min(ans, 2 * (x + y));
            else ans = min(ans, 2 * abs(x - y) - 1);
        }
    }
    cout << ans << '\n';
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    cin >> t;
    while (t--)solve();
    return 0;
}

Carrot Trees

#线段树 #扫描线 #差分

题目翻译

Walk Alone 在一排中种植了 n n n 棵魔法胡萝卜树。设 a i a_i ai 表示第 i i i 棵树上的胡萝卜数量（注意 a i a_i ai 是一个实数）。初始时，所有树上都没有胡萝卜。在每一天，他可以对树执行以下两种操作之一：

1 l r x：浇灌从 l l l 到 r r r（包括两端）的所有胡萝卜树。之后，对于所有 l ≤ i ≤ r l \leq i \leq r l≤i≤r， a i a_i ai 立即增加 x / k x / k x/k，其中 k k k 是所有操作中的一个常数。
2 l r：从所有在 l l l 到 r r r（包括两端）范围内且至少有一个胡萝卜的树上各采摘一个胡萝卜。之后，对于所有满足 l ≤ i ≤ r l \leq i \leq r l≤i≤r 且 a i ≥ 1 a_i \geq 1 ai≥1 的整数 i i i， a i a_i ai 减少 1 1 1。

经过 m m m 天后，Walk Alone 采摘了许多胡萝卜，他希望你能告诉他总共收获了多少胡萝卜。

输入描述

第一行包含三个整数 n n n ( 1 ≤ n ≤ 1 0 6 ) (1 \leq n \leq 10^6) (1≤n≤106)、 m m m ( 1 ≤ m ≤ 2 ⋅ 1 0 5 ) (1 \leq m \leq 2 \cdot 10^5) (1≤m≤2⋅105) 和 k k k ( 1 ≤ k ≤ 1 0 9 ) (1 \leq k \leq 10^9) (1≤k≤109)，分别表示胡萝卜树的数量、操作的数量以及第一种操作中的常数。

接下来的 m m m 行每行表示一个操作，格式如上所述。保证 1 ≤ l ≤ r ≤ n 1 \leq l \leq r \leq n 1≤l≤r≤n 且 1 ≤ x ≤ 1 0 9 1 \leq x \leq 10^9 1≤x≤109。

输出描述

输出一个整数，表示总共收获的胡萝卜数量。

思路

赛时写了个暴力的线段树，维护区间的最大值与最小值，每次取萝卜的时候先判断最小值与 k k k的大小，再决定是否往下二分

但是这样的写法通过 80 % 80\% 80%就 T L E TLE TLE了

这是因为，最极限的情况时，不能取萝卜的位置与能取萝卜的位置交替出现，此时线段树 q u e r y query query操作复杂度来到了 o ( n ) o(n) o(n)

实际上，本题的输出内容值得考量：只询问所有操作结束后收到萝卜的总和

首先，将操作1的增加 x k \frac{x}{k} kx改为 x x x，操作二的 − 1 -1 −1改为 − k -k −k，这样一来所有的数字都是整数

考虑单个位置 p o s pos pos的萝卜数量 c c c变化情况：

如果不加入 a i ≥ k a_{i}\geq k ai≥k的限制，那么在第 i i i次操作后，萝卜数量 c i c_{i} ci可能会变成负数

记第 p o s pos pos位置被收了 d d d次萝卜（不考虑限制）,则真正收到的萝卜需要考虑上被多收的部分，这一部分即为 ∣ m i n { c i } ∣ |min\{ c_{i} \}| ∣min{ci}∣ ，再考虑 k k k的问题，多收的萝卜即为 ⌈ ∣ m i n { c i } ∣ k ⌉ \left\lceil \frac{|min\{ c_{i} \}|}{k} \right\rceil ⌈k∣min{ci}∣⌉

因此，当前位置总共收的萝卜即为 d − ⌈ ∣ m i n { c i } ∣ k ⌉ d-\left\lceil \frac{|min\{ c_{i} \}|}{k} \right\rceil d−⌈k∣min{ci}∣⌉

接下来就是如何求得所有位置 p o s pos pos在不考虑限制时的最小萝卜数

维护最小值可以想到使用线段树，而要维护 n n n个位置的最小值，考虑在 1 ∼ n 1\sim n 1∼n上打差分

使用扫描线+线段树遍历 1 ∼ n 1\sim n 1∼n，每扫过一个 p o s pos pos，让扫描线上的线段树执行 p o s pos pos上的所有操作，随后调用根节点即可获取当前 p o s pos pos的最小萝卜数

代码

cpp 复制代码

#include<iostream>
#include<vector>
#include<unordered_map>
#include<map>
#include<unordered_set>
#include<set>
#include<algorithm>
#include<cmath>

using namespace std;
const double eps = 1e-6;
#define ll long long
#define int ll
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define see(stl) for(auto&ele:stl)cout<<ele<<" ";cout<<'\n';
#pragma GCC optimize(3, "Ofast", "inline")

const int N = 1e6 + 5;
int n, m, k;

#define ls p<<1
#define rs p<<1|1
#define mid (l+r>>1)
int mi[N << 2], add[N << 2];
void pushup(int p) {
    mi[p] = min(mi[ls], mi[rs]);
}
void pushdown(int p, int l, int r) {
    if (add[p]) {
        mi[ls] += add[p];mi[rs] += add[p];
        add[ls] += add[p];add[rs] += add[p];
        add[p] = 0;
    }
}
void update(int p, int l, int r, int x, int y, int val) {
    if (x <= l && r <= y) { mi[p] += val;add[p] += val; return; }
    pushdown(p, l, r);
    if (x <= mid)update(ls, l, mid, x, y, val);
    if (y > mid)update(rs, mid + 1, r, x, y, val);
    pushup(p);
}
struct que {
    int op, l, r, x;
};
vector<que>q[N];

void solve() {
    cin >> n >> m >> k;
    rep(i, 1, m) {
        int op;cin >> op;
        if (op == 1) {
            int l, r, x;cin >> l >> r >> x;
            q[l].push_back({ 1,i,m,x });
            q[r + 1].push_back({ 1,i,m,-x });
        } else {
            int l, r;cin >> l >> r;
            q[l].push_back({ 2,i,m,-k });
            q[r + 1].push_back({ 2,i,m,k });
        }
    }
    int ans = 0, d = 0;
    rep(i, 1, n) {
        for (auto [op, l, r, x] : q[i]) {
            if (op == 1) {
                update(1, 1, m, l, r, x);
            } else {
                if (x < 0)d++;
                else d--;
                update(1, 1, m, l, r, x);
            }
        }
        int del = -min(0ll, mi[1]);
        ans += d - (del + k - 1) / k;
    }
    cout << ans << '\n';
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)solve();
    return 0;
}