Codeforces Round 885 (Div. 2)

A. Vika and Her Friends

题目大意

太长了 click

思路

可以手动模拟一下，可以发现当两个人的 $x + y$ 值就行相同的就能抓到了

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        int n, m, k;
        cin >> n >> m >> k;
        bool flag = false;
        int a, b;
        cin >> a >> b;
        for (int i = 1; i <= k; i++)
        {
            int c, d;
            cin >> c >> d;
            if ((a + b - (c + d)) % 2 == 0)
                flag = true;
        }
        if (!flag)
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }
    return 0;
}

B.Vika and the Bridge

题目大意

有 $n$ 块木板排成一排，第 $i$ 块木板的颜色是 $c_{i}$ ，你站在第一块木板前面，需要跳跃到第 $n$ 块木板后面，每一次只能跳相同颜色的木板。现在你可以更改一块木板的颜色，使得你每一次跳跃的距离(指两块木板中间部分，不计两端点)的最大值最小，请求出这个值。

思路

首先我们知道一个结论，当一个点到另一个与它相同颜色的点的距离是最大的，那么，我们只要在中间插上一个与其颜色相同的点就能让最大长度的除以 2 。

我们考虑维护最大距离 $f m a x$ 和次大距离 $s m a x$ ，最后统计 $min {max {\frac{f m a x_{i}}{2}, s m a x_{i}}}$ 即可

int distance = i - last[a[i]] - 1;
if (distance > fimax[a[i]])
{
    smax[a[i]] = fimax[a[i]];
    fimax[a[i]] = distance;
}
else if (distance > smax[a[i]])
    smax[a[i]] = distance;
---------------------------------------
last[a[i]] = i;
int ans = 1e9 + 7;
for (int i = 1; i <= m; i++)
	ans = min(ans, max(smax[i], fimax[i] / 2));

C.Vika and Price Tags

题目大意

给定 $n$ $(1 \leq n \leq 1 \times 10^{5})$ 对整数 $a, b$ $(1 \leq a, b \leq 1 \times 10^{9})$ ，每次使 $a \leftarrow b$ ， $b \leftarrow∣ a - b ∣$ ，求是否能实现让所有的 $a$ 在有限次同步操作后都变为 $0$ 。

思路

这道题显然用到了“更相减损法”，既然是更相减损，那么就会想到词 $gcd$

对于 $a, b (a > b)$ 的最大公因数 $gcd (a, b)$ , 有

$gcd (a, b) = gcd (b, a - b)$

在更相减损法的过程中 $gcd (a, b)$ 显然不变，最后使得 $a = 0$ ，此时 $gcd (a, b)$ 为 $b$

最终满足题目序列的序列的是这样的

$0$	$0$	$0$	$0$
$gcd (a_{1}, b_{1})$	$gcd (a_{2}, b_{2})$	$gcd (a_{3}, b_{3})$	$. . .$

我们只需要讨论所要的 $gcd (a_{i}, b_{i})$ 能不能同时出现。

对于满足条件的数对 $(0, b)$ 在操作过程中的状态可能是 $(0, b), (b, b), (b, 0)$ ，并在三种状态中有序循环

考虑简化，对于数对 $(a, b)$ ，在进行 $k$ 此操作后可以形成 $(0, x)$ 满足条件的数对，那么对于数对 $(q a, q b)$ 可以在进行 $k$ 次操作后，一定变成 $(0, q x)$ ，在所有操作中 $q$ 可以当成公因数提出

同理，数对 $(a, b)$ 与数对 $(\frac{a}{gcd (a, b)}, \frac{b}{gcd (a, b)})$ 等价

接下来用互质给数对 $(a, b)$ 进行分类，当 $a$ 与 $b$ 互质时，会有

$a$	奇	偶	奇
$b$	偶	奇	奇

如何证明以上就是我们所需的三种分类呢？

设 $a = 2 k, b = 2 k + 1$

$a$	$2 k$	$2 k + 1$	$1$	$2 k$	$2 k - 1$	$1$	$2 k - 2$	...
$b$	$2 k + 1$	$1$	$2 k$	$2 k - 1$	$1$	$2 k - 2$	$2 k - 3$	...

发现数对 $(a, b)$ 总是在给出的三种情况反复循环

以奇奇，奇偶开始同理

所以我们证明了，数列能否合法，只与其间数对的奇偶性有关。如果数对的奇偶性有且仅有唯一的一种，那么就能成立。

int work(int x, int y)
{
    int gcc = gcd(x, y);
    x /= gcc, y /= gcc;
    if (x % 2 == 0)
        return 0;
    if (y % 2 == 0)
        return 1;
    return 2;
}
-------------------------------
for (int i = 1; i <= n; i++)
{
    if (a[i] == 0 && b[i] == 0)
        continue;
    res = work(a[i], b[i]);
    if (res == 0) sum0 = 1;
    if (res == 1) sum1 = 1;
    if (res == 2) sum2 = 1;
}

D.Vika and Bonuses

题目大意

共 $T \leq 10^{5}$ 组数据。

每组数据给定 $s, k$ $(s, k \leq 10^{9})$ 。

你需要维护一个计数器 $C$ （初始为 0）并进行 $k$ 次操作，每次操作形如二者之一：

$C \leftarrow C + s$
$s \leftarrow s + s mod 10$ .

输出 $k$ 次操作后 $C$ 的最大值。

思路

对于每一次增加后的各位情况，我们可以手玩一下

这里假设 $s = 1$

$0 \to 0, 1 \to 2, 2 \to 4, 3 \to 6, 4 \to 8, 5 \to 0, 6 \to 2, 7 \to 4, 8 \to 6, 9 \to 8$

我们发现个位要么变成 $0$ ，要么就在 $2 \to 4 \to 8 \to 6$ 这里循环。

当 $s$ 个位数为 $0$ 时，操作再多次也没用，为 $5$ 时，显然操作一次就会变成 $0$ ，同理。

我们发现 $2 \to 4 \to 8 \to 6$ 是一轮循环，且这轮循环后，s会增加 $20$ ,我们设进行 $x$ 轮循环后答案为 $y$ ，容易列出方程

y = (s + 20 x) (k - 4 x)

化 简 得

y = - 80 x^{2} + (20 k - 4 s) x + s k

很容易看出一元二次方程的 $a = - 80, b = (20 k - 4 s), c = s k$

这里推一下极值点坐标

y = a x^{2} + b x + c

y = a [x^{2} + 2 \frac{b}{2 a} x + (\frac{b}{2 a})^{2}] + c - a \frac{b^{2}}{(2 a)^{2}}

y = a (x + \frac{b}{2 a})^{2} + c - \frac{b^{2}}{4 a}

这 里 通 过 x + \frac{b}{2 a} 来 推 极 值 可 得

当 x = - \frac{b}{2 a}, 就 得 出 来 了

带 入 加 约 分 易 得

x = \frac{5 k - s}{40}

但这个数不一定是整数，所以我们要拿上取整合下取整计算答案并取 $max$ , 但是我们这样只能计算单个个位数的情况，因此我们要在计算答案以前，枚举个位数，再对答案取 $max$ 。

#include <bits./stdc++.h>
using namespace std;
typedef long long LL;
LL s, k;

LL work(LL s, LL k)
{
    LL ans = s * k;
    LL x = max(min((5 * k - s) / 40, k / 4), 0ll);
    ans = max(ans, -80 * x * x + (20 * k - 4 * s) * x + s * k);
    x = min(x + 1, k / 4);
    ans = max(ans, -80 * x * x + (20 * k - 4 * s) * x + s * k);
    return ans;
}

LL solve()
{
    cin >> s >> k;
    if (s % 10 == 0)
        return s * k;
    if (s % 10 == 5)
        return max(s * k, (s + 5) * (k - 1));
    LL ans = s * k;
    if (s % 2)
        s += s % 10, k--;
    for (int i = 1; i <= 4; i++)
    {
        if (k <= 0)
            break;
        ans = max(ans, work(s, k)), s += s % 10, k--;
    }
    return ans;
}

int main()
{
    LL t;
    cin >> t;
    while (t--)
        cout << solve() << endl;
    return 0;
}

__EOF__

本文作者：ljfyyds
本文链接：https://www.cnblogs.com/ljfyyds/p/17599084.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！