Codeforces Round #783 (Div. 2)和Codeforces Round #784 (Div. 4)---- ABC | ABCDEF

已于 2022-04-24 00:24:33 修改
阅读量408 收藏
点赞数 1
分类专栏： codeforces 总结 文章标签： 算法 c++
于 2022-04-24 00:24:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60777643/article/details/124367433
版权

 

目录

Codeforces Round #783 (Div. 2)

A

 B

C 

 Codeforces Round #784 (Div. 4)

A

B

 C

 D

E

F 

Codeforces Round #783 (Div. 2)

A

题意：给定一个长宽分别为n，m的网格，起点为（1，1）每次可以上下左右移动，但这一次的移动不能与上一次的移动相同。问到右下角（n，m）的最小操作数。

思路：（图是借的qwq）

不能重复移动且步数最小的方法当然是沿着对角线右下移动，可以看到，移动到底边的时候就不能这样移动了，但是此时与终点同一水平线上。从图上可以看到，从左上右下移动的时候横坐标移动到min(n,m)，纵坐标移动到min(n,m)所以如果当n==m且n和m没有等于1的，因为m和n中有一个为1说明移动只有一个方向，且另一个不为1则至少移动两次，产生矛盾。

所以总体思路就是先按右下移动到底边的（min(n,m),min(n,m))点处，然后剩下的步数则与剩下位移奇偶有关，剩下距离为奇的时候步数为2*(n-m)-1，反之为2*(n-m)。最后讨论一下特殊情况。


#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long
const int N = 2e5 +10;
using namespace std;
int T,n,m;
ll arr[N];
int  slove() {
     
        cin >> n >> m;
        int sum = 0;
        if (n < m)swap(n, m);
        if (m == 1) {
            if (n >2)
                return -1;
            else
                return n - 1;
        }
        else {
            sum = 0;
            sum = 2 * (m - 1);
            if ((n - m) % 2 == 1) {
                sum +=( 2 * (n - m))-1;
            }
            else
                sum += (2 * (n - m));
        }
        return sum;    
}
int main()
{
     ios::sync_with_stdio(false);cout.tie(NULL);    
     cin >> T;
     while (T--)
         cout << slove()<< endl;
}

 B

题意：

有 n个人围坐在圆桌旁，圆桌有m把椅子。

每个人希望其左侧、右侧分别至少有 a[i]个空椅子。判断所有人是否都能有座位。

思路：每个人的隐私距离是可以重叠的，由贪心，隐私距离重叠的越多，圆桌越有可能坐下所有人。所以考虑尽量多重叠隐私距离。但是后一个人的隐私距离又不能超过前一个人的隐私距离，不然前一个人不符合要求。所以考虑先对隐私距离排序，从最大开始安排座位就能保证前一个人不会和后一个人矛盾。我们先安排隐私距离最大人a[n]先坐，后一个人a[n-1]紧挨着前一个人的隐私距离此时所占的位置数为(2*a[n]+1)+a[n-1]+1，可以看到每次安排新人的时候位置数都增加了a[i]+1,

现在考虑最后一个人，最后一个人因为隐私距离最小，不用考虑重叠问题，只需要此时剩下至少一个位置即可。

#include <iostream>
#include<Windows.h>
#include<map>
#include<string>
#include<algorithm>
using namespace std;

 int T,n,m;
 const int N=2e5 +10;

int main()
{
        cin>>T;
        while(T--){
            cin>>n>>m;
            int arr[N];
            for(int j=1;j<=n;j++)cin>>arr[j];
            sort(arr+1,arr+1+n);
            int sum=arr[n];//初始化
            int ok=0;
            for(int j=n;j>=2;j--){
                sum+=arr[j]+1;每次增加占位数
                if(sum>=m){
                    ok=1;
                    break;
                }
            }
            if(ok){
                cout<<"NO"<<endl;
            }
            else 
                cout<<"YES"<<endl;

        }
    return 0;
}

C 

 题意：有一个长为n的数组  a[n]和 元素全为0的b[n]。b[i]每次可以加上或减去a[i]，问最少多少次操作可以使b[n]为严格递增序列。

思路：最少步骤的严格递增序列，且初始化为0，必定存在一个位置a[i]为0

以a[i] 为分界线，左侧的绝对值和右侧都是严格递增的，也就是左侧的靠左的绝对值|a[i-1]|一定比相邻靠右的绝对值|a[i+1]|至少大1，右侧靠右的a[i+1]至少比a[i]大1。所以按此逻辑枚举0分界点，取最小值即可。

#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long
const int N = 2e5 +10;
using namespace std;
int mp[4][4];
int T,n;
ll arr[N];
int main()
{
    ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> n;
    for (int j = 1; j <= n; j++) {
        cin >> arr[j];
    }
    ll ans = LLONG_MAX;
    for (int j = 1; j <= n; j++) {
        ll now = 0, sum = 0;
        for (int i = j - 1; i >= 1; i--) {
            ll t=(ceil((double)(now+1)/arr[i]));//前一个至少比当前少一
            sum += t;
            now =   t * arr[i];
        }
        now = 0;//换界记录值初始化
        for (int i = j + 1; i <= n; i++) {
            ll t = ceil((double)(now + 1) / arr[i]);
            sum += t;
            now = t * arr[i];
        }
        ans = min(ans, sum);
    }
    cout << ans << endl;

}

 Codeforces Round #784 (Div. 4)

A

A太水了懒得写。

B

 题意：输出出现至少三次的数，没有返回0；

思路：桶/hash计数，没啥好说的。


#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long

using namespace std;
int T, n;
int main()
{
    /* freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);*/
    ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> T;
    while (T--) {
        int ok = 0;
        int arr[200001] = { 0 }, b[200001] = { 0 };
        cin >> n;
        for (int j = 1; j <= n; j++) {
            cin >> arr[j];
            b[arr[j]]++;

        }
        for (int j = 0; j <= n; j++) {
            if (b[j] >= 3) {
                cout << j << endl;
                ok = 1;
                break;
            }
        }
        if(!ok)
        cout << -1 << endl;
    }
}

 C

题意：给定一个序列a[n]，每次可以给下标为奇数i的元素a[i]全部加上1也可以给下标为偶数j的元素a[j]全加上1，问多次或0次操作后a序列能否使a序列全部元素都相等。

思路：很简单，如果相邻的奇数或偶数元素存在不相等的情况，那么如何操作都不能使这不相等的两个元素相同，因为他们都是共同加1的。


#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long
using namespace std;
int T, n;
int main()
{
    /* freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);*/
    ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> T;
    while (T--) {
        int n;
        int arr[100] = { 0 };
        cin >> n;
        for (int j = 1; j <= n; j++) {
            int t;
            cin >> t;
            if (t % 2 == 0)
                arr[j] = 0;
            else
                arr[j] = 1;
        }
        int ok = 0;
        for (int j = 3; j <= n; j++) {
            if (arr[j] != arr[j - 2]) {
                ok = 1;
                break;
            }
        }
        if (ok)
            cout << "NO" << endl;
        else cout << "YES" << endl;

    }
}

 D

 题意：

给定长度为n的方格，方格默认为白色W，可以用长度为2的一半红R一半蓝B的邮票贴入，可以RB的贴也可以BR的贴，后来的颜色会覆盖原来的颜色，现给定一个长度为n的方格，问这串方格是否是合法的。

思路：

这题算是个结论题，可以先找找规律。显然当两个W之间存在连续的R或者B肯定是不合法的。所以去统计两个W之间的R和B的个数，如果只有其中一个为0，说明不合法。对于第一个颜色和最后一个颜色，我们可以在头尾加上W使其一般化。

#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long

using namespace std;
int T, n;
int main()
{
    /* freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);*/
    ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> T;
    while (T--) {
        string s;
        cin >> n;
        cin >> s;
        s += 'W';
        int ok = 0;
        int r = 0, b = 0, cnt = 0;
        
        for (int j = 0; j <= n; j++) {
            if (s[j] == 'W') {
                if ((r == 0 || b == 0) && cnt != 0) {
                    ok = 1;
                    break;
                }
                else
                    r = 0, b = 0, cnt = 0;//重置计算下一段
            }
            else {
                if (s[j] == 'R')r++, cnt++;
                if (s[j] == 'B')b++, cnt++;
            }
        }
        if (!ok)
            cout << "YES" << endl;
        else
            cout << "NO" << endl;

    }
}

E

题意：

每次给出n个长度为2且由a-k的字母组成的字符串，问存在多少对只有其中一个对应下标的字符不同的字符串对数。

思路：
这题可以从字符串长度只有2入手，如果其中一个字符和另一个字符串的相应位置字符相同，，那么要满足题目要求，另一个位置上的字符则必须不同于另一个字符串相应位置的字符。

对于这种情况如果直接逐个比对必会超时，所以采用hash计数，第一个hash1得到第一个位置上该字符出现的次数，hash2得到第二个位置上该字符串出现次数，hash3处理这两个字符串完全相等的情况，其值为整个字符串出现次数。所以 其中一个字符相同的情况 减去 两个字符都相等的情况则能得到当前字符对应相同但另一个位置的字符对应不同的情况。那么显然对于前 i 个字符串，符合题目要求的字符串对数sum=（hash1-hash3）+（hash2-hash3）

#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long

using namespace std;
int T, n;
int main()
{
    /* freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);*/
    ios::sync_with_stdio(false); cout.tie(NULL);

    cin >> T;
    while (T--) {
        ll N, n = 0;
        cin >> N;
        map<char, int>m1, m2;
        map<string, int>m3;
        while (N--) {
            string s; cin >> s;
            n += m1[s[0]] + m2[s[1]] - 2 * m3[s];
            m3[s]++; m1[s[0]]++; m2[s[1]]++;
        }
        cout << n << endl;
    }
}

F 

 题意：

有一列重量不一的糖果，一个人从左边连续的吃，另一个人从右边连续的吃。输出能使两人吃的糖果总重量相同的被吃糖果总数。

思路：

其实题目很简单，也没有卡时间，我的原始思路是用两个前缀和处理两个人分别吃到某个糖果已经吃的总重量。然后枚举其中一个人吃的糖果总数，再二分查找另一个人可以吃的糖果总数是否有与第一个人当前吃的相等的，并且不断更新糖果总数最大值。

#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long

using namespace std;
int T, n;
ll sum1[200001] = { 0 }, sum2[200001] = { 0 };
ll my_find(ll t) {//二分查找
    ll l = 0, r = n + 1;
    ll mid;
    while (l + 1 != r) {
        mid = (l + r) >> 1;
        if (sum2[mid] > t) {
            l = mid;
        }
        else
            r = mid;
    }
    return r;
}
int main()
{
 ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> T;
    while (T--) {
        cin >> n;
        ll ans = 0;
        for (int j = 1; j <= n; ++j) {
            ll t;
            cin >> t;
            sum1[j] = sum1[j - 1] + t;
        }
        for (int j = 1; j <= n; ++j) {
            sum2[j] = sum1[n] - sum1[j];//后缀和处理
        }
        for (int j = 1; j <= n; ++j) {
            if (sum1[j] > (sum1[n] / 2)){//过半剩下的不可能相等，舍去
                break;
            }
            ll t = my_find(sum1[j]);//二分查找后缀和相等处
            if (t < n && sum2[t] == sum1[j]) {
                ans = j + (n - t);
            }
        }
        cout << ans << endl;
    }
}

整体时间复杂度为O(n*log)但是因为处理前后缀常数会稍大。

还有个做法，很明显一个从左吃一个从右吃要使总和相等，就是一个双指针问题，用两个指针记录双方各吃到的位置，再分别用两个变量记录吃到当前位置的总重量，然后根据当前情况调整指针即可。

#include <iostream>
#include<ctime>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<unordered_map>
#include<unordered_set>
#define ll long long
const int N = 2e5;
using namespace std;
int T, n;
int w[N+10];
void slove() {
    for (int j = 1; j <= n; ++j)cin >> w[j];
    ll ans = 0, l = 0, r = n + (ll)1;
    ll a = 0, b = 0;
    while (l + 1 <= r) {
        if (a == b) {//相等时更新答案的最大值
            ans = l + (n - r) + 1;
            a += w[++l]; b += w[--r];//指针全部偏移
        }
        else {//两边重量不等时调整指针
            if (a > b) {
                b += w[--r];
            }
            else
                a += w[++l];
        }
    }
    cout << ans << endl;
}
int main()
{

    ios::sync_with_stdio(false); cout.tie(NULL);
    cin >> T;
    while (T--) {
        cin >> n;
        slove();
     }
}

 

                 

Brokenrivers
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
长度为n的字符串包含n−2n−2n−2个aaa和222个bbb，求按照字典序排列输出第kkk个字符串 解题思路 第一个bbb在倒数第二位有1个字符串，在倒数第三位有2个字符串…在倒数第nnn位时有n−1n-1n−1个字符串 可以根据第一...
Codeforces Round #783 (Div. 1) B. Optimal Partition
我们仍未知道那天所看见的花的名字。
04-25 143
#include<bits/stdc++.h> using namespace std; #define int long long const int N=5e5+10; const int mod= 998244353; struct node{ int l,r,val; }tr[3][N<<2]; int t,n,a[N],s[N],now=0; const int M=-1e9; void pushup(int p){ tr[now][p].val=max(t
A. Make it Increasing-Codeforces Round #783 (Div. 1)
jisuanji2606414的博客
06-11 199
Problem - 1667A - CodeforcesA. Make it Increasingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given an array aa consisting of nn positive integers, and an array bb, with length nn. Initially
Codeforces Round 783 补题
热爱计算机语言！
04-20 990
目录官网链接div2C Make it Increasingdiv1B Optimal PartitionC Half Queen CoverD Edge EliminationE Centroid ProbabilitiesF Yin Yang 官网链接 div2 C Make it Increasing You are given an array a consisting of n positive integers, and an array b, with length n. Initially
Codeforces Round #455 (Div. 2) A-C
weixin_30916125的博客
12-28 66
A; A. Generate Login time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output The preferred way to generate us...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
littlegengjie的博客
05-13 584
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 376
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 300
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
力扣阶段练习(1).消失的数字
2301_79475128的博客
05-11 839
恰好。这便是使用异或寻找缺失数的思路。
第33次CSP认证Q1：词频统计
XingziYY的博客
05-10 263
在学习了文本处理后，小 P 对英语书中的 𝑛n 篇文章进行了初步整理。具体来说，小 P 将所有的英文单词都转化为了整数编号。假设这 𝑛n 篇文章中共出现了 𝑚m 个不同的单词，则把它们从 11 到 𝑚m 进行编号。这样，每篇文章就简化为了一个整数序列，其中每个数都在 11 到 𝑚m 范围内。
解双曲型非线性方程的Harden-Yee算法(TVD格式)
程序员的博客
05-11 281
解双曲型非线性方程的Harden-Yee算法。先贴代码，教程后面有空再写。
代码随想录算法训练营第三十五天| 435. 无重叠区间 763.划分字母区间 56. 合并区间
2301_79829307的博客
05-10 350
再遍历一遍数组，用right和left代表分段的右左区间端点，取right和字母最远的边界的最大值更新right，如果right==i,那就找到了分割点。如果i的左端点>i+1的右端点，把区间的左端点更新为i和i+1左端点的最大值。遍历数组，如果i的右区间大于i-1的左区间，就没有重叠，需要更新左区间。遍历数组，如果i的右区间大于i-1的左区间，就没有重叠，需要更新左区间。先用哈希表遍历一遍数组，同时记录每个字母出现的次数。找到出现过字母的最远边界，该点就是分割点。判断何时更新区间的右端点。
算法练习第22天|39. 组合总和、40.组合总和II
最新发布
Brillian123的博客
05-15 808
39. 组合总和39. 组合总和 - 力扣（LeetCode）
codeforces round #783 (div. 2)
03-16
Codeforces Round #783 (Div. 2) 是 Codeforces 竞赛平台上的一场比赛，属于 Div. 2 级别。比赛时间为 2 小时，参赛者需要在规定时间内解决尽可能多的题目，获得尽可能高的分数。该比赛的题目难度较为适中，适合初学...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值