Codeforces Round 922 (Div. 2)（A~D）

木木警官

已于 2024-01-31 11:12:07 修改

阅读量980

点赞数 31

文章标签： c++

于 2024-01-31 11:06:31 首次发布

本文链接：https://blog.csdn.net/zjdysq/article/details/135947929

版权

文章详细解释了四个编程题目：BrickWall涉及填满格子的最优策略，MinimizeInversions要求在保持数组有序的同时减少逆序对，XOR-distance通过异或操作调整数列，BlockingElements使用二分查找和双端队列解决区间和限制问题。

摘要由CSDN通过智能技术生成

A. Brick Wall

用横着的砖填满格子

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n, m;
    cin >> n >> m;
    cout << m / 2 * n << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

B. Minimize Inversions

这题要求 $A$ 数组和 $B$ 数组中的逆序对个数之和最少

我们假设 $A$ 数组有序，此时调整 $A$ 数组中的元素，若交换 $a_i$ 和 $a_j$ ，则会多出 $j - i$ 个逆序对，是最不优情况

所以当一个数组有序的时候即为答案

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
struct sj
{
    int a, b;
} x[N];
bool cmp(sj x, sj y)
{
    return x.a < y.a;
}
void solve()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)
    cin >> x[i].a;
    for(int i = 1;i <= n;i++)
    cin >> x[i].b;
    sort(x+1,x+n+1,cmp);
    for(int i = 1;i <= n;i++)
    cout << x[i].a << " ";
    cout << '\n';
    for(int i = 1;i <= n;i++)
    cout << x[i].b << " ";
    cout << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

C. XOR-distance

我们使小的数变大，大的数变小，但是小的数不能大于大的数

记小的数为 $a$ ，大的数为 $b$ ，如果当前位 $a$ 为 $0$ 且 $b$ 为 $1$ ，通过异或操作，可以使得前位 $a$ 为 $1$ 且 $b$ 为 $0$ ，从最高位到最低位依次操作

注意，每次操作要考虑是否超过范围 $r$

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int a, b, r;
    cin >> a >> b >> r;
    int rr = r, cnt = 0, sum = 0;
    while(rr > 0)
    {
        rr /= 2;
        cnt++;
    }
    for(int i = cnt;i >= 0;i--)
    {
        if(a > b)
        swap(a, b);
        int aa = (a ^ (1LL << i)), bb = (b ^ (1LL << i));
        if(((1LL << i) & a) == 0 && ((1LL << i) & b) > 0 && aa < bb)
        {
            if(sum + (1LL << i) <= r)
            {
                sum += (1LL << i);
                a = (a ^ (1LL << i));
                b = (b ^ (1LL << i));
            }
        }
    }
    cout << abs(a - b) << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

D. Blocking Elements

二分答案，看选中的数之和是否超过 $mi d$

$dp_i$ 为最后一个选中的数为 $a_i$ 时的最小代价，所以我们只需要判断 $dp_{n+1}$ 和 $mi d$ 的大小关系

如果当前选中的位置为 $i$ ，由于要满足每段之和小于等于 $mi d$ ，所以我们可以得到满足条件的最前面的选点 $j$ ，可以通过双指针处理出 $j$

所以 $dp_i$ 的转移方程为 $dp_i = max(min(dp[k]) +a[i]),(j \leqslant k \leqslant i - 1)$

为了使时间复杂度满足题目要求，我们可以用双端队列优化，总时间复杂度为 $O (n l o g n)$

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n;
    cin >> n;
    vector<int> a(n+5);
    for(int i = 1;i <= n;i++)
    cin >> a[i];
    int l = 1, r = 1e16;
    while(l <= r)
    {
        deque<int> q;
        q.push_back(0);
        int mid = (l + r) / 2, cnt = 0;
        vector<int> dp(n+5);
        for(int i = 1, j = 0;i <= n + 1;i++)
        {
            while(cnt > mid)
            cnt -= a[++j];
            while(!q.empty() && q.front() < j) q.pop_front();
            dp[i] = dp[q.front()] + a[i];
            while(!q.empty() && dp[q.back()] >= dp[i]) q.pop_back();
            cnt += a[i];
            q.push_back(i);
        }
        if(dp[n + 1] > mid)
        l = mid + 1;
        else
        r = mid - 1;
    }
    cout << l << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

木木警官

关注

31
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
Codeforces Round 922 (Div. 2)（A~D）

为了使时间复杂度满足题目要求，我们可以用双端队列优化，总时间复杂度为。我们使小的数变大，大的数变小，但是小的数不能大于大的数。，所以我们可以得到满足条件的最前面的选点。所以当一个数组有序的时候即为答案。注意，每次操作要考虑是否超过范围。二分答案，看选中的数之和是否超过。时的最小代价，所以我们只需要判断。，通过异或操作，可以使得前位。，由于要满足每段之和小于等于。数组中的逆序对个数之和最少。，从最高位到最低位依次操作。，可以通过双指针处理出。数组中的元素，若交换。为最后一个选中的数为。如果当前选中的位置为。
复制链接

扫一扫