Codeforces Round 854 by cybercats (Div. 1 + Div. 2)部分题解

已于 2023-03-13 14:28:52 修改
阅读量497 收藏
点赞数 3
文章标签： javascript 前端 html
于 2023-03-09 17:11:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62676987/article/details/129409673
版权

Codeforces Round 854 by cybercats (Div. 1 + Div. 2)

C. Double Lexicographically Minimum

题意：给你一个字符串 s ，你可以重排 s 中的字母而得到字符串 t 。定义 t_{max} 为 t 和 rev(t)（rev(t) 是 t 前后翻转得到的字符串）中字典序较大者。现在你需要让 t_{max} 的字典序最小，并输出t_{max} 。

题解：

考虑构造，显然可以从小到大枚举 s 的所有字符，设当前枚举到 x：

1、若 x 还剩下至少两个，则将答案的前缀和后缀各加上 x；

2、若除 x 外只剩下一种字符 y ，设其出现次数为 k ，则将前缀加上 \left \lceil \frac{k}{2} \right \rceil 个 y ，加上 x ，再加上\left \lfloor \frac{k}{2} \right \rfloor 个 y；

3、否则将剩下的、不包括 x 的所有字符按字典序加入前缀，再加入 x。

具体代码如下：

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#define int long long
#define quick_cin() cin.tie(0),ios::sync_with_stdio(false)
#define endl "\n"
#define pb push_back
#define all(x) x.begin(), x.end()
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 100010, M = 5010;
const int Mod = 1e9 + 7;
const int INF = 1e18;
 
int n, T, m, k;
string a;
char b[N];
int tmp[30];

void solve()
{
    memset(tmp, 0, sizeof tmp);
    cin >> a;
    n = a.length();
    
    for (auto i : a) tmp[i - 'a'] ++ ;
    
    int backup = -1;
    int l = 0, r = n - 1;
    for (int i = 0; i < 26; i ++ )
    {
        while (tmp[i] > 1)
        {
            b[l ++ ] = b[r -- ] = i + 'a';
            tmp[i] -= 2;
        }
        if (tmp[i])
        {
            backup = i;
            break;
        }
    }
    
    if (~backup)
    {
        int f = 0;//置1为后面只剩v一个字母，置0反之
        for (int i = backup + 1; i < 26; i ++ )
        {
            if (tmp[i])
            {
                if (tmp[i] + 1 == r - l + 1) f = 1;
                break;
            }
        }
        
        if (f)
        {
            for (int i = 0; i < 26; i ++ )
                while (tmp[i] > 1)
                    b[l ++ ] = b[r -- ] = i + 'a', tmp[i] -= 2;
        }
        
        b[r -- ] = backup + 'a', tmp[backup] -- ;
        
        for (int i = 0; i < 26; i++)
            while (tmp[i])
                b[l ++ ] = i + 'a', tmp[i] -- ;
    }
    
    for (int i = 0; i < n; i ++ ) cout << b[i];
    cout << endl;
}

signed main()
{
//    quick_cin();
    cin >> T;
//    getchar();
//    T = 1;

    while (T -- )
    {
        solve();
    }
    
    return 0;
}

D1. Hot Start Up (easy version)

题意：你有两个 CPU，n 个程序要运行，总共 k 种程序需要运行。程序按顺序进行，每次执行程序如果你选择的 CPU 上一次运行的程序不是你当前运行的程序，则需要花费 cold_{i} 的时间。否则，需要花费 hot_{i}​ 的时间。

题解：在本题当中按照题意本应该定义 f[i][j][k]  表示放完第 i 个物品并且第一条序列末尾是 j 并且第二条序列末尾是 k 时最小的花费，这样会变成 O(n^{3}) 的时间复杂度，但是放完第 i 个物品时就可以知道其中一个的末尾元素了，即a[i] ，因此数组变成 f[i][j] ，表示放完第 i 个物品后其中一条序列后另一条子序列的结尾是 j 时的最小花费。

此时的状态转移方程：

第一种——放在第 i-1 个元素的后面

f[i][j] = min(f[i][j], f[i - 1][j] + (a[i] == a[i - 1] ? hot[a[i]] : cold[a[i]]));

第二种——不放在第 i-1 个元素的后面，此时另一条自序列的末尾肯定是 a[i-1]

f[i][a[i - 1]] = min(f[i][a[i - 1]], f[i - 1][j] + (a[i] == j ? hot[a[i]] : cold[a[i]]));

具体代码如下：

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#define int long long
#define quick_cin() cin.tie(0),ios::sync_with_stdio(false)
#define endl "\n"
#define pb push_back
#define all(x) x.begin(), x.end()
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 5010, M = 5010;
const int Mod = 1e9 + 7;
const int INF = 1e18;
 
int n, T, m, k;
int res;
int f[N][N];//表示放完第i个物品并且另一个CPU最后程序是j的最小花费
int a[N], hot[N], cold[N];

void solve()
{
    cin >> n >> k;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    for (int i = 1; i <= k; i ++ ) cin >> cold[i];
    for (int i = 1; i <= k; i ++ ) cin >> hot[i];
    
    for (int i = 0; i <= n; i ++ )
            for (int j = 0; j <= k; j ++ )
                f[i][j] = INF;
    
    f[1][0] = cold[a[1]];
    for (int i = 2; i <= n; i ++ )
    {
        int last = a[i - 1];
        for (int j = 0; j <= k; j ++ )
        {
            //放在第i-1个程序后面
            f[i][j] = min(f[i][j], f[i - 1][j] + (a[i] == last ? hot[a[i]] : cold[a[i]]));
            //不放在第i-1个程序后面
            f[i][last] = min(f[i][last], f[i - 1][j] + (a[i] == j ? hot[a[i]] : cold[a[i]]));
        }
    }
    
    res = INF;
    for (int i = 0; i <= k; i ++ )
        res = min(res, f[n][i]);
    
    cout << res << endl;
}

signed main()
{
    quick_cin();
    cin >> T;
//    getchar();
//    T = 1;

    while (T -- )
    {
        solve();
    }
    
    return 0;
}

D2. Hot Start Up (hard version)

题意：在上一题的基础上扩大了 n 和 k 的取值范围，此时 O(nk) 会TLE。

题解：观察之前的二维 DP ， f_{i-1} 与 f_{i}​ （此时反过来好思考一点）之间的转移也分为两种情况（与之前的两个情况相对应）：

1、对于所有的 f_{i,j} 等于 f_{i-1,j} 加上 cold_{a[i]} 或者 hot_{a[i]} （由 a[i] 是否等于 a[i-1] 决定）；

2、此外，对于f_{i, a[i-1]} 还可以取 min(f_{i-1}+cold_{a[i]},f_{i-1,a[i]}+hot_{a[i]}) 。

具体代码如下：

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#define int long long
#define quick_cin() cin.tie(0),ios::sync_with_stdio(false)
#define endl "\n"
#define pb push_back
#define all(x) x.begin(), x.end()
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 300010, M = 5010;
const int Mod = 1e9 + 7;
const int INF = 1e18;
 
int n, T, m, k;
int res;
int a[N], hot[N], cold[N];

struct Node
{
    int l, r;
    int v;  // 区间[l, r]中的最小值
    int add;
}tr[N * 4];

void pushup(int u)
{
    tr[u].v = min(tr[u << 1].v, tr[u << 1 | 1].v);
}

void pushdown(int u)
{
    auto &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if (root.add)
    {
        left.add += root.add, left.v += root.add;
        right.add += root.add, right.v += root.add;
        root.add = 0;
    }
}

void build(int u, int l, int r)
{
    tr[u] = {l, r};
    if (l == r)
    {
        tr[u].v = INF;
        return;
    }
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}

int query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;
    
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    int v = INF;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = min(v, query(u << 1 | 1, l, r));

    return v;
}

void modify(int u, int p, int val)//单点取min
{
    if (tr[u].l == p && tr[u].r == p)
    {
        tr[u].v = min(tr[u].v, val);
        return;
    }
    else
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (mid >= p) modify(u << 1, p, val);
        else modify(u << 1 | 1, p, val);
        pushup(u);
    }
}

void modify(int u, int l, int r, int d)//区间加
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].v += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].add += d;
    }
    else    // 一定要分裂
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, d);
        if (r > mid) modify(u << 1 | 1, l, r, d);
        pushup(u);
    }
}

void solve()
{
    cin >> n >> k;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    for (int i = 1; i <= k; i ++ ) cin >> cold[i];
    for (int i = 1; i <= k; i ++ ) cin >> hot[i];
    
    build(1, 0, k);
    res = INF;
    
    modify(1, 0, 0);
    
    for (int i = 1; i <= n; i ++ )
    {
        res = min(query(1, 0, k) + cold[a[i]], query(1, a[i], a[i]) + hot[a[i]]);//区间查询
        modify(1, 0, k, a[i] == a[i - 1] ? hot[a[i]] : cold[a[i]]);//区间加
        modify(1, a[i - 1], res);//单点修改
    }
    printf("%lld\n", query(1, 0, k));

}

signed main()
{
    quick_cin();
    cin >> T;
//    getchar();
//    T = 1;

    while (T -- )
    {
        solve();
    }
    
    return 0;
}

E. City Union

题意：给你一个 n × m 的网格图，每个点为 '#' 或 '.'。定义一个城市为一个 '#' 的连通块。一开始原图中有两个城市，要求你用最少次将某个格子变为 '#' 的操作使得图中只有一个城市，满足其中任意两个 '#' 的只经过 '#' 的最短路长度为它们的曼哈顿距离（在两点 (a, b) 和 (c, d) 之间的曼哈顿距离为 \left | a-c \right | + \left | b-d \right | ）。

题解：

首先考虑满足第二个条件，发现如果有两个 '#' 之间的最短路会绕成 C 形则不满足。于是发现每一行每一列都必须为一段连续的 '#'，否则断开的两段中任意两点的最短路不满足要求。

于是需要将每一行每一列填满成一个连续段。

然后还有可能是两个城市，我们需要将它们连在一起，应该各取一个坐标为已填了的点中最大（小）横坐标和最大（小）纵坐标的点，随便连一条最短路，然后再填满。

可以发现这样做需要填的格子数量是最小的。

具体代码如下：

#pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#define int long long
#define quick_cin() cin.tie(0),ios::sync_with_stdio(false)
#define endl "\n"
#define pb push_back
#define all(x) x.begin(), x.end()
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 110, M = 5010;
const int Mod = 1e9 + 7;
const int INF = 1e18;
 
int n, T, m, k;
int res;
multiset<int> S;
char dist[N][N];
int l[N], r[N];

void solve()
{
    S.clear();
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )
    {
        l[i] = 51, r[i] = 0;
        for (int j = 1; j <= m; j ++ )
        {
            cin >> dist[i][j];
            if (dist[i][j] == '#')
            {
                r[i] = j, S.insert(j);
                if (l[i] > 50) l[i] = j;
            }
        }
    }
    
    for (int i = 1; i <= n; i ++ )
        if (l[i] < 51)
        {
            for (int j = l[i]; j <= r[i]; j ++ )
            {
                if (dist[i][j] == '.')
                    dist[i][j] = '#';
                else
                    S.erase(S.find(j));
            }
            
            if (!S.empty())
            {
                if (*S.begin() < l[i])//防止产生向左的谷底
                    l[i + 1] = min(l[i + 1], l[i]);
                else//防止两个联通块之间不连接
                    l[i + 1] = min(r[i], *S.begin());
                
                if (*S.rbegin() > r[i])//防止产生向右的谷底
                    r[i + 1] = max(r[i + 1], r[i]);
                else//防止两个联通块之间不连接
                    r[i + 1] = max(l[i], *S.rbegin());
            }
        }
    
    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= m; j ++ )
            cout << dist[i][j];
        cout << endl;
    }
}

signed main()
{
    quick_cin();
    cin >> T;
//    getchar();
//    T = 1;

    while (T -- )
    {
        solve();
    }
    
    return 0;
}

MMMMirean
关注
Codeforces Round #749 (Div.1+Div.2)A-D题解
qq_54026781的博客
10-19 199
A. Windblume Ode 题意：就是从n个数里面挑p（要求最大）个数的和为合数，输出所挑选的数的下标，顺序随便 思路：p的可能值只有n or n-1,如果所有加起来的和为合数，输出n，否则，在奇数中挑一个数减去，使得和为合数, 证明：假设偶数有a个，奇数有b个，a个偶数相加肯定为合数， （1）如果b是偶数，则奇数可以两两配对，所以最后的和为偶数,肯定为合数 （2）如果b为奇数，那么最后的和可能为合数，可能不是，如果不是，和肯定为奇数，所以需要减去一个奇数，使得和为合数 代码 #include<
Codeforces Round #854 by cybercats (Div. 1 + Div. 2)
m0_62289613的博客
02-28 2058
Codeforces Round #854 by cybercats (Div. 1 + Div. 2)
Codeforces Round 854 by cybercats (Div. 1 + Div. 2)C. Double Lexicographically Minimum
weixin_63128867的博客
03-15 482
不管怎么放，a的对称位置一定是b，翻转后都变成了b，什么时候字典序更大，越靠做越重要，如果a放中间左侧，如abbbb,翻转后,bbbba,肯定max是取后者，babbb翻转后，bbbab，也是取后者，bbabb,翻转后就是本身，bbbab，翻转后babbb，取前者，bbbba翻转后abbbb，取前者，为了让a放到更前面的位置，a应该放正中间，因为放左边的都会被翻转掉，所以这种情况取把其他字符对半分配，然后放中间。对于成对的同一字母来说，最好的是前面一个，后面一个，而且是字典序比较小的在外围更优；
Codeforces Round #792 (Div. 1 + Div. 2)
m0_61409183的博客
05-22 490
目录 A. Digit Minimization B. Z mod X = C C. Column Swapping D. Traps A. Digit Minimization A. Digit Minimization 题意解释： 先交换两位数字， 在删除最后一位数字，如此循环到只剩一个数字，输出该数字。 问：输出的最小数字是多少： 思路：当只有一位数字时，直接输出；两位数字时，先交换，删除，再输出，即为个位的数字 其他情况下，总能使最后剩下的数字为最小的数字，找到最小的数字输
Codeforces LATOKEN Round 1 (Div. 1 + Div. 2)题解
XLH1129的博客
06-14 296
D. Lost Tree 有n个点的树，让你猜哪些是边 选择一个点r，可以得到其它点到r的最短距离 可以询问n/2次!!!向上取整!!! 那就是间隔一层询问一次 看以1为根结点时，奇数层的个数与偶数层个数的大小 int n,r,x,a[maxn]; int cnt1,cnt2; bool is[maxn][maxn]; void solve() { sd(n); printf("? 1\n");fflush(stdout); cnt2=-1; rep(i,1,n) { sd(a[i]);
【10.29】Codeforces Round #831 (Div. 1 + Div. 2)
ZhgDgE的博客
10-31 350
题意：给你一棵树，每次你可以删除一个没有儿子的点并将这个点的值放入序列中，如果父节点比这个要删除的节点大那么父节点的值变为这个值。我们的目标为构造树的点权并且以一种顺序删除点，使得最后的序列最长非下降子序列最长。每次可以移动最顶端的一个棋子到相邻的位置，棋子除了在起点和终点都不能重叠，而且不能向起点处放棋子以及不能从终点处拿出棋子。可以想到，对于一棵树，可以构造使得这棵树的其中一个子树的最大的值小于另一个子树的最小的。记录：任一时刻，除了起点和终点的其他地方放的棋子数量的最大值。思路：贪心的想，如何使得。
Codeforces Round #502 (Div. 1 + Div. 2)
Dmaxiya
08-09 586
Contests 链接：Codeforces Round #502 (Div. 1 + Div. 2) 过题数：4 排名：765/7399 A. The Rank 题意 一个班上有 nnn 个学生，每个学生都有一个 ididid 和四门课的成绩，每个学生的 ididid 为 111 到 nnn 之间的整数，每个学生的 ididid 都不相同，将所有学生按总分从高到低排序，若总分...
Codeforces Round #749 (Div. 1 + Div. 2, based on Technocup 2022 Elimination Round 1）简训
C_eeking的博客
10-19 331
Codeforces Round #749 (Div. 1 + Div. 2, based on Technocup 2022 Elimination Round 1） 这次题还蛮有意思的
Codeforces Round #758 (Div.1 + Div. 2)
m0_56005735的博客
12-12 306
题目列表1.A. Find Array-Codeforces Round #758 (Div.1 + Div. 2)2,B. Build the Permutation-Codeforces Round #758 (Div.1 + Div. 2) 1.A. Find Array-Codeforces Round #758 (Div.1 + Div. 2) 题意:给定n，要求构建一个数组有n个元素，而且每个元素(不包括最后一个元素)都不能被后一个元素整除。 题解:输出从2到n+1的值就可以了。 解释:因为
Contest 2050 and Codeforces Round #718 (Div. 1 + Div. 2)
我的故事用酒换
04-24 165
2021.4.23 A 题意：给一个数n，判断n能否被2050*10^k中取的数相加得到。 题解：每个相加的数都是2050的倍数，所以直接判断n能否被2050整除得到，可以的话直接加上商的位数和。 #include <cstdio> #include <iostream> #include <algorithm> #define ll long long using namespace std; int main() { ll t,n; sca
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 371
Codeforces
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1061
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
Codeforces Round #661 (Div. 3) 题解
qq_46365538的博客
08-06 288
Codeforces Round #661 (Div. 3) A. Remove Smallest #include<bits/stdc++.h> using namespace std; #pragma GCC optimize(2) typedef long long ll; typedef unsigned long long ull; typedef long double ld; const int N=100; int t,n,a[N]; int main() {
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 659
【代码】【JavaScript】LeetCode：707设计链表。
前端vue3打印，多页打印，不使用插件（工作中让我写一个打印功能）
最新发布
m0_51798113的博客
09-17 313
getTableData().tableData，其实就是去后端获取参数去了，因为这是公司的前端框架，基于vxe的，包装的方法，获取了一个表格信息，相当于获取参数。说下总体思路，创建一个组件，里面放多个span字段，然后根据父组件传入的参数，生成子组件，最好我们打印子组件的信息即可。这里也很关键，中间我遇到一个问题，那就是经常第一次点击按钮，dom元素没有加载完，就弹出打印框了，所以我加了一个异步事件，还有记得把抽屉关了。
使用 uni-app 开发微信小程序的详细指南
2301_79685859的博客
09-16 748
uni-app是一个使用 Vue.js 框架开发跨平台应用的前端框架。开发者通过编写一套代码，可以生成多端应用，包括 H5、iOS、Android、微信小程序、支付宝小程序、字节跳动小程序等。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 653
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
Vue接入高德地图并实现基本的路线规划功能
黄团团的个人博客
09-11 564
找到public目录下的index.html文件，把刚才申请好的2个密钥分别粘贴进去，第一个securityJsCode是填入安全密钥，第二个红框是填入Key。登录高德开放平台，点击我的应用，先添加新应用，然后再添加Key。如图所示填写对应的信息，系统就会自动生成。
codeforces round #792 (div. 1 + div. 2)
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内提交他们的解决方案，然后等待评测结果。最终，根据参赛者的得分和排名，评选出获胜者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值