Codeforces Round #851 (Div. 2) 题解记录

故园春雨

已于 2023-02-19 14:48:36 修改

阅读量307

点赞数 1

文章标签：算法 c++ 数据结构贪心算法动态规划

于 2023-02-13 14:35:35 首次发布

本文链接：https://blog.csdn.net/arcsin_90/article/details/129008433

版权

Codeforces Round #851 (Div. 2)

B. Sum of Two Numbers

给定一个整数n，找出两个满足下列条件的非负整数x和y。

$x + y = n$
$x$ 的位数之和与 $y$ 的位数之和最多相差1。

输出任意一组 $x, y$

数据范围：多组数据 $\le t \le 10000,1 \leq n \leq 10^9$

input

output

Note

In the second test case, the sum of digits of 67 and the sum of digits of 94 are both 13.

In the third test case, the sum of digits of 60 is 6, and the sum of digits of 7 is 7.

思路：

对于第 $i$ 位数字 $d_i$ ，如果 $d_i$ 是偶数，则 $x, y$ 各获得 $\frac{d_i}{2}$ ，如果是奇数，则 $x$ 获得 $\frac{d_i}{2}$ ， $y$ 获得 $\frac{d_i+1}{2}$ ，下一次遇到奇数则让 $y$ 获得 $\frac{d_i}{2}$ ， $x$ 获得 $\frac{d_i+1}{2}$ ，这样可以保证 $x, y$ 的数位之和之差不超过1

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<map>
#include<set>
#include<functional>
#include<unordered_set>
#include<queue>
#include<stack>
#include<cmath>
#include<cctype>
#include<cstring>
using namespace std;
typedef long long ll;
const int N = 5e4 + 5;
int main()
{
    cin.tie(0), cout.tie(0);
    ios::sync_with_stdio(0);
    int t;
    cin >> t;
    while (t--) {
        string s;
        cin >> s;
        bool flag = 1;
        string a, b;
        for (int i = 0; i < s.size(); i++) {
            int t = s[i] - '0';
            if (t % 2 == 0) {
                a += (t / 2) + '0';
                b += (t / 2) + '0';
            }
            else if (flag) {
                a += (t / 2) + '0';
                b += (t / 2 + 1) + '0';
                flag = 0;
            }
            else {
                b += (t / 2) + '0';
                a += (t / 2 + 1) + '0';
                flag = 1;
            }
        }
        cout << stoi(a) << " " << stoi(b) << "\n";
    }
    return 0;
}

C. Matching Numbers

给定一个 $1\sim2n$ 的排列，将 $1$ 至 $2 n$ 的整数两两配对，变成 ${a_1,b_1,a_2,b_2,...,a_n,b_n\}$ ，满足 ${a_1+b_1,a_2+b_2,...,a_n+b_n\}$ 为严格递增序列，且相邻差值为1，即 $a_1+b_1+1=a_2+b_2$ ， $a_2+b_2+1=a_3+b_3$ ，以此类推。

数据范围：多组数据 $t$ ， $1\le t\le500,$ $\leq n \leq 10^5$ ，n的总和不超过 $10^5$

思路：

由等差数列求和公式：
$\frac{n(s_1+s_1+n-1)}{2}=\frac{2n(1+2n)}{2}\\ s_1=\frac{3+3n}{2}$
当 $n$ 为偶数时，无解

当 $n$ 为奇数时，对小数据暴力后可发现规律，
$\{a_1,a_2,...,a_n\}=\{1,2,...,n\}\\ \{b_1,b_2,...,b_n\}=\{n+1+\frac{n}{2},n+2+\frac{n}{2},...,2n,n+1,n+2,...,n+\frac{n}{2}\}$
即
${a_1,a_2,...,a_n\}=\{1,2,3,4,5\}\\ \{b_1,b_2,...,b_n\}=\{8,9,10,6,7\}\\ \{s_1,s_2,...,s_n\}=\{8+1,6+4,9+2,7+5,10+3\}=\{9,10,11,12,13\}$

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<map>
#include<set>
#include<functional>
#include<unordered_set>
#include<queue>
#include<stack>
#include<cmath>
#include<cctype>
#include<cstring>
using namespace std;
typedef long long ll;
const int N = 5e4 + 5;
int main()
{
    cin.tie(0), cout.tie(0);
    ios::sync_with_stdio(0);
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        if (n % 2 == 0) {
            cout << "No" << "\n";
            continue;
        }
        int j = 1;
        cout << "Yes" << "\n";
        if (n == 1) {
            cout << "1 2" << "\n";
        }
        else {
            for (int i = n + 1 + n / 2; i <= 2 * n; i++) cout << j++ << " " << i << "\n";
            for (int i = n + 1; i < n + 1 + n / 2; i++) cout << j++ << " " << i << "\n";
        }
    }
    return 0;
}

D. Moving Dots

给定数轴上的 $n$ 个点，第 $i$ 个点的初始坐标是 $x_i$ 。这些坐标是不同的。每个点以相同的恒定速度同时开始移动。每个点都向最近的点（相邻两点，坐标之差的绝对值最小）的方向移动，直到它遇到另一个点。在平局（与左右两点坐标之差的绝对值相同）的情况下，它向左移动，两个点碰撞之后就会停止移动。经过足够的时间，每个点都会停止移动。游戏的结果是点停止时的不同坐标的数量。

我们需要计算所有大于两个点的子集结果的总和。由于结果可能非常大，所以要打印 $10^9+7$ 的模数之和。

数据范围： $\leq n \leq 3000,1 \leq x_1 < x_2 < \ldots < x_n \leq 10^9$

Examples

input

4
1 2 4 6

output

input

5
1 3 5 11 15

output

在第一个例子中，对于一个大小为2的子集，两个点向对方移动，所以有一个坐标是碰撞点。

对于大小为3的子集，第一个点和第三个点向第二个点移动，因此，无论第二个点移动的方向如何，都有一个坐标让两个点停下来。

对于 $[1, 2, 4, 6]$ ，第一个点和第二个点向对方移动。对于第三个点，最初，第二个点和第四个点是最接近的点。由于它是一个平局，第三个点向左移动。第四个点也向左移动。因此，碰撞点是1.5

因为有6个大小为2的子集，4个大小为3的子集和1个大小为4的子集，所以答案是 $6 \cdot 1 + 4 \cdot 1 + 1 = 11$ 。

思路：

考虑枚举碰撞情况，计算每两个点碰撞对答案产生的贡献，也即有多少种情况， $i, j$ 两点直接相撞

如上图所示，4和1碰撞，那么4和1中间的点必然不选，同时需要满足4不会往左撞，1不会往右撞，4与1的距离是3，那么1需要排除右边两个点，至于图中绿色的点可选可不选，它们不影响碰撞结果，所以4和1碰撞产生的贡献为 $2^3*2^1=16$

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<map>
#include<set>
#include<functional>
#include<unordered_set>
#include<queue>
#include<stack>
#include<cmath>
#include<cctype>
#include<cstring>
using namespace std;
typedef long long ll;
int mod = 1e9 + 7;
ll qmi(ll a, ll b, ll p) {
    ll res = 1;
    while (b) {
        if (b & 1) res = (res * a) % p;
        b >>= 1;
        a = (a * a) % p;
    }
    return res;
}
int main()
{
    cin.tie(0), cout.tie(0);
    ios::sync_with_stdio(0);
    int n;
    cin >> n;
    ll ans = 0;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) {
        int l = i - 1, r = i + 1;
        // 枚举i与j相撞，i和j中间的点不选
        for (int j = i + 1; j <= n; j++) {
            int d = a[j] - a[i];
            // i一定不能往左边撞
            while (l >= 1 && a[i] - a[l] <= d) --l;
            // j一定不能往右边撞
            while (r <= n && a[r] - a[j] < d) ++r;
            ans = (ans + qmi(2, l, mod) * qmi(2, n - r + 1, mod)) % mod;
        }
    }
    cout << ans;
    return 0;
}

E. Sum Over Zero

给你一个n个整数 $a_1, a_2, \ldots, a_n$ 的数组。考虑 $S$ 是一组满足以下条件的线段。 $S$ 的每个元素应该是 $[x, y]$ 的形式，其中 $x$ 和 $y$ 是 $1$ 和 $n$ 之间的整数，包括端点在内，并且 $x \leq y$ 。在 $S$ 中所有线段互不相交，且对于 $S$ 中的每个 $[x, y]$ ， $a_x+a_{x+1}+ \ldots +a_y \geq 0$
线段 $[x, y]$ 的长度被定义为 $y - x + 1$ 。 $f (S)$ 被定义为 $S$ 中每条线段的长度之和，即 $\sum_{[x, y] \in S} (y - x + 1)$ 。注意，如果 $S$ 是空的， $f (S)$ 是 $0$ 。

在所有可能的 $S$ 中，最大的 $f (S)$ 是多少？

数据范围： $\leq n \leq 2 \cdot 10^5$ , $-10^9 \leq a_i \leq 10^9$

input

5
3 -3 -2 5 -4

output

input

10
5 -2 -4 -6 2 3 -6 5 3 -2

output

input

4
-1 -2 -3 -4

output

在第一个例子中， $S=\{[1, 2], [4, 5]\}$ 可能是一个 $S$ ，因为 $a_1+a_2=0$ ， $a_4+a_5=1$ 。 $S=\{[1, 4]\}$ 也可以是一个可能的解决方案。

由于不存在任何满足 $f (S) > 4$ 的 $S$ ，答案是 $4$ 。

在第二个例子中， $S=\{[1, 9]\}$ 是唯一能满足 $f (S) = 9$ 的集合。由于每个可能的 $S$ 都满足 $\leq 9$ ，所以答案是 $9$ 。

在第三个例子中， $S$ 只能是一个空集，所以答案是 $0$ 。

思路：

定义 $d p [i]$ 为前 $i$ 个位置选出的线段长度之和的最大值， $s u m$ 为前缀和数组，那么转移方程为
$dp[i]=\mathop{max}\limits_{\substack{j<i\\sum[i]-sum[j]\ge0}} \{dp[j]+i-j,dp[i-1]\}$
显然我们需要用线段树来优化dp，线段树记录每个位置的dp值减去自身下标后的值，即 $d p [j] - j$ ，线段树维护最大值，且为权值线段树，每个点对应前缀和数组的值，根据 $a_i$ 的值可知需要对数据离散化进行线段树的下标映射，每次枚举 $i$ 点转移时，查询 $\le sum[i]$ 的区间中最大值即可。

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<map>
#include<set>
#include<functional>
#include<unordered_set>
#include<queue>
#include<stack>
#include<cmath>
#include<cctype>
#include<cstring>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5, inf = (1 << 30);
int dp[N];  //dp[i]表示遍历到第i位时满足条件的最大区间总长
// 从数组a中选择若干个子数组，满足每个子数组的和分别>=0，
// 并且使得所有子数组的长度加起来尽可能的大
struct info {
    int maxval;
    info operator + (const info& t) const {
        info res;
        res.maxval = max(maxval, t.maxval);
        return res;
    }
};
struct Node {
    int l, r;
    info val;
}tr[4 * N];
void pushup(int u) {
    tr[u].val = tr[u << 1].val + tr[u << 1 | 1].val;
}
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if (l == r) {
        tr[u] = { l, l, -inf };
        return;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    pushup(u);
}
void update(int u, int pos, int val) {
    if (tr[u].l == pos && tr[u].r == pos) {
        tr[u].val.maxval = max(tr[u].val.maxval, val);
        return;
    }
    int mid = (tr[u].l + tr[u].r) >> 1;
    if (pos <= mid) update(u << 1, pos, val);
    if (pos > mid) update(u << 1 | 1, pos, val);
    pushup(u);
}
info query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].val;
    int mid = (tr[u].l + tr[u].r) >> 1;
    if (l > mid) return query(u << 1 | 1, l, r);
    else if (r <= mid) return query(u << 1, l, r);
    else return query(u << 1, l, r) + query(u << 1 | 1, l, r);
}
void discretize(vector<ll>& pos, vector<ll>& a) {
    pos.assign(a.size(), 0);
    vector<ll> tmp = a;
    sort(tmp.begin() + 1, tmp.end());
    tmp.erase(unique(tmp.begin() + 1, tmp.end()), tmp.end());
    for (int i = 1; i <= a.size() - 1; i++) {
        pos[i] = lower_bound(tmp.begin() + 1, tmp.end(), a[i]) - tmp.begin();
    }
}
int main()
{
    cin.tie(0), cout.tie(0);
    ios::sync_with_stdio(0);
    int n;
    cin >> n;
    vector<ll> a(n + 1), sum(n + 1), pos;
    for (int i = 1; i <= n; i++) cin >> a[i], sum[i] = sum[i - 1] + a[i];
    build(1, 1, N);
    sum.push_back(0);
    discretize(pos, sum);
    update(1, pos[n + 1], 0);
    for (int i = 1; i <= n; i++) {
        dp[i] = i + query(1, 1, pos[i]).maxval;
        dp[i] = max(dp[i], dp[i - 1]);
        update(1, pos[i], dp[i] - i);
    }
    cout << dp[n];
    return 0;
}

故园春雨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round #851 (Div. 2) 题解记录

每个点都向最近的点（相邻两点，坐标之差的绝对值最小）的方向移动，直到它遇到另一个点。如上图所示，4和1碰撞，那么4和1中间的点必然不选，同时需要满足4不会往左撞，1不会往右撞，4与1的距离是3，那么1需要排除右边两个点，至于图中绿色的点可选可不选，它们不影响碰撞结果，所以4和1碰撞产生的贡献为。对于大小为3的子集，第一个点和第三个点向第二个点移动，因此，无论第二个点移动的方向如何，都有一个坐标让两个点停下来。在第一个例子中，对于一个大小为2的子集，两个点向对方移动，所以有一个坐标是碰撞点。
复制链接

扫一扫