Codeforces Global Round 10（ABCD题解）

最新推荐文章于 2020-08-20 21:19:24 发布
最新推荐文章于 2020-08-20 21:19:24 发布
阅读量177 收藏
点赞数
分类专栏： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43559193/article/details/108053698
版权 
					A. Omkar and Password

.
在这里插入图片描述

在这里插入图片描述
题意：
给你一个长度为n的数组，你每次可以选择两个相邻的不相等的数把它们变成他俩的和，如 [ 1 2 3 4 ] ，你可以选择 2 ，3 。 然后把他俩合并成5，原序列变为 [ 1 5 4 ] 。
问你在进行任意多次操作后，原数组最少剩下几个数。
思路：
情况1：如果原数组只有一种数，答案是n。
情况2：否则答案是1.
简单证明：
情况一无需证明。
情况二： 你可以每次选择一个最大的数，让他变得更大，一直下去，最后就会只剩一个数。

				B. Omkar and Infinity Clock

.
在这里插入图片描述
在这里插入图片描述
题意：
给你一个长度为n的数组和一个数k，然后定义了一种修改操作，每次修改操作都是用当前数组中的最大值去更新该数组，更新公式是a[i]=该数组中的最大值 - a[i] 。问你进行k次操作后该数组会变成什么样子。
思路：
手写几下会发现一个性质，该数组除去初始形态后只有两种状态，对标每个a[i]就是max-a[i] , a[i]-min 这两个数中来回切换，自己推一推也很好证明。
然后就是把k取余2，直接输出答案就行。

.

					C. Omkar and Waterslide

.
在这里插入图片描述

在这里插入图片描述

题意：
给你一个长度为n的数组，你每次可以选择一段连续的非递减的序列，把他们都加1，问你最少要几次操作，使得这个序列整体变成非递减序列。
思路：
贪心+思维。
这个题倒着想会简单一些，倒着想的话很容易发现：
如果当前a[i]<a[i-1],ans+= a[i-1]-a[i] ;这样写的话，ans就是最终答案。
我不会证明。。。 但是这样应该很好想到。。。
吐槽：
刚开始理解错题意，以为每次只能加一个数，那样的话可以用rmq写。有兴趣的可以试试。

.

					D. Omkar and Bed Wars

.

在这里插入图片描述

在这里插入图片描述

题意：（白嫖群友一波题意。）
有n个人排成一个圈
每个人要么向左攻击要么向右攻击
他们需要满足一下的条件：
如果一个玩家正被另外一个玩家攻击，那么他应该打回去
如果一个玩家被0个或2个其他玩家攻击，那么他往左或往右打都行
你可以花费一次代价修改一个人的攻击方向 问最后满足条件的最小修改代价

思路：
有两种写法（我只会两种。。。）
第一种是dp，dp [len] [i] [j] [ii] [jj] 含义是长度为len的第一个人攻击方向是i，第二个人攻击方向是j，倒数第二个人攻击方向是ii，倒数第一个人攻击方向是jj。 然后状态转移就可以了，具体过程看代码。
第二种是找规律，手写一些样例发现 连续三个人的攻击方向相同的话 是不合法的。然后一段攻击方向相同的人的贡献是长度/2，把每一段的贡献都计算出来求和就好了；不过如果所有人的攻击方向都一样的话要特判一下，自己简单模拟一下也很容易发现规律。具体思路见代码。

							代码A

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+15;
typedef long long ll;
ll a[N];
int main()
{
    ll t;
    cin>>t;
    while(t--)
    {
        ll n,f=0;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        for(int i=2;i<=n;i++)
        {
            if(a[i]!=a[i-1])
                f=1;
        }
        if(f==1)
        {
            cout<<"1"<<endl;
        }
        else
        {
            cout<<n<<endl;
        }
    }
    return 0;
}



						代码B

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+15;
typedef long long ll;
ll a[N];
int main()
{
    ll t;
    cin>>t;
    while(t--)
    {
        ll n,k,maxn,op;
        maxn=-1123456789123;
          op=-1123456789123;
        cin>>n>>k;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            maxn=max(maxn,a[i]);
        }
        for(int i=1;i<=n;i++)
        {
            a[i]=maxn-a[i];
            op=max(op,a[i]);
        }
        if(k%2==1)
        {
            for(int i=1;i<=n;i++)
            {
                cout<<a[i]<<" ";
            }
            cout<<endl; continue;
        }
        for(int i=1;i<=n;i++)
        {
            a[i]=op-a[i];
            //op=max(op,a[i]);
        }
        for(int i=1;i<=n;i++)
        {
             cout<<a[i]<<" ";
        }
        cout<<endl;
    }
    return 0;
}



							代码C

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+15;
typedef long long ll;
int a[N],n;
int dp[N][20];
int mm[N],s[N];
void initRMQ()
{
    mm[0] = -1 ;
    for(int i=1;i<=n;i++)
    {
        mm[i]=  ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
        dp[i][0]=a[i];
    }
    for(int j=1;j<=mm[n];j++)
    {
        for(int i=1;i+(1<<j)-1<=n; i++ )
        {
            dp[i][j] = max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        }
    }
}
int rmq(int x,int y)
{
    int k = mm[y-x+1];
    return max(dp[x][k],dp[ y-(1<<k)+1 ][k] );
}
int main()
{
    ll t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        for(int i=n;i>=2;i--)
        {
            if(a[i]<a[i-1])
                ans+=(a[i-1]-a[i]);
        }
        cout<<ans<<endl;
    }
    return 0;
}



					  代码D（DP）

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+15;
typedef long long ll;
char str[N];
ll ans=0;
ll a[N];
ll dp[N][2][2][2][2];
const ll inf=11234567891234;
int main()
{
    ll t,n,k;
    cin>>t;
    while(t--)
    {
        cin>>n; ans=0;
        scanf("%s",str+1);
        for(int i=1;i<=n;i++)
        {
            if(str[i]=='R') a[i]=1;
            else            a[i]=0;
            a[n+i]=a[i];
        }
        int lk=0;
        for(int i=1;i<=n;i++)
        {
            if(a[i]==a[n])
                lk=i;
            else
                break;
        }
        for(int i=1;i<=n;i++)
            a[i]=a[lk+i];
        if(n<=2)
        {
            cout<<"0"<<endl;    continue;
        }
        for(int i=2;i<=n;i++)
        {
            if(str[i]!=str[i-1])
            {
                k=i;    break;
            }
        }
        for(int l=1;l<=n;l++)
        {
            for(int i=0;i<=1;i++)
            {
                for(int j=0;j<=1;j++)
                {
                    for(int ii=0;ii<=1;ii++)
                    {
                        for(int jj=0;jj<=1;jj++)
                        {
                            dp[l][i][j][ii][jj]=inf;
                        }
                    }
                }
            }
        }
        if(a[1]==1)
        {
            dp[2][1][0][1][0]=0;
            dp[2][1][1][1][1]=0;
            dp[2][0][0][0][0]=1;
            dp[2][0][1][0][1]=1;
        }
        else
        {
            dp[2][1][0][1][0]=1;
            dp[2][1][1][1][1]=1;
            dp[2][0][0][0][0]=0;
            dp[2][0][1][0][1]=0;
        }
        if(a[2]==1)
        {
            dp[2][1][0][1][0]++;
            //dp[2][1][1][1][1]=0;
            dp[2][0][0][0][0]++;
            //dp[2][0][1][0][1];
        }
        else
        {
            //dp[2][1][0][1][0]++;
            dp[2][1][1][1][1]++;
            //dp[2][0][0][0][0]++;
            dp[2][0][1][0][1]++;
        }
        ll op1,op2,op3;
        for(int l=3;l<=n;l++)
        {
            for(int i=0;i<=1;i++)
            {
                for(int j=0;j<=1;j++)
                {
                    for(int ii=0;ii<=1;ii++)
                    {
                        for(int jj=0;jj<=1;jj++)
                        {
                            op1=op2=op3=inf;
                            if(ii!=0||jj!=0)
                                op1=dp[l-1][i][j][0][ii];
                            if(ii!=1||jj!=1)
                                op2=dp[l-1][i][j][1][ii];
                            if(l==n)
                            {
                                if( ( (ii==jj)&&(jj==i) ) || ((jj==i)&&(i==j)) )
                                    op1=inf,op2=inf;
                            }
                            op3=min(op1,op2);
                            if(a[l]==jj)
                            {
                                dp[l][i][j][ii][jj]=min(dp[l][i][j][ii][jj],op3);
                            }
                            else
                            {
                                dp[l][i][j][ii][jj]=min(dp[l][i][j][ii][jj],op3+1);
                            }
                        }
                    }
                }
            }
        }
        ll opp=inf;
        for(int i=0;i<=1;i++)
        {
            for(int j=0;j<=1;j++)
            {
                for(int ii=0;ii<=1;ii++)
                {
                    for(int jj=0;jj<=1;jj++)
                    {
                        opp=min(opp,dp[n][i][j][ii][jj]);
                    }
                }
            }
        }
        cout<<opp<<endl;
    }
    return 0;
}


						代码D（找规律）

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+15;
typedef long long ll;
char str[N];
ll ans=0;
ll a[N];
ll dp[N][2][2][2][2];
const ll inf=11234567891234;
int main()
{
    ll t,n,k;
    cin>>t;
    while(t--)
    {
        cin>>n; ans=0;
        scanf("%s",str+1);
        for(int i=1;i<=n;i++)
        {
            if(str[i]=='R') a[i]=1;
            else            a[i]=0;
            a[n+i]=a[i];
        }
        int lk=0;
        for(int i=1;i<=n;i++)
        {
            if(a[i]==a[n])
                lk=i;
            else
                break;
        }
        if(lk==n)
        {
            if(lk<=2)
                cout<<"0"<<endl;
            else
                cout<<(lk+2)/3<<endl;
            continue;
        }
        for(int i=1;i<=n;i++)
            a[i]=a[lk+i];
        ll op=1;
        a[n+1]=3;
        //cout<<a[1]<<" ";
        for(int i=2;i<=n+1;i++)
        {
          //  cout<<a[i]<<" ";
            if(a[i]==a[i-1])
                op++;
            else
            {
                ans+=op/3;  //if(op%3==2&&op>3) ans++;
                op=1;
            }
        }
        //cout<<endl;
        cout<<ans<<endl;
    }
    return 0;
}
imiMppPpPpPpp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Global Round 10
Fighting_Peter的博客
08-17 231
这种大场全是神仙打架，向我这种菜菜就是掉分www太难了 神仙打架，百姓遭殃。 A - Omkar and Password 分析可以知道，只要数组元素不是全部相等答案就是1，如何数组元素全部相等答案就是n。 #define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0) #pragma GCC optimize(2) #include<iostream> #include<algorithm> using namespace
【题解】Codeforces Global Round 10 -- C
Inquisitor_的博客
08-17 215
题目：https://codeforces.ml/problemset/problem/1392/C 题意 输入一串数，每次选择一串不降序列，使该序列中所有数全部+1。 求出至少经过多少次操作能使原序列整体变为不降序列。 题解 从右向左遍历原序列，当前遍历到的数为a[i]，前一个数为a[i-1]。若a[i] < a[i-1]，则将a[i]补至a[i-1]即可；若a[i] > a[i-1]，则无视之，不需做任何操作。 算法正确性比较明显：从右向左遍历遍历到数a[i]时，a[i+1],a[i+2],
Codeforces Global Round 10 部分题解
curry的博客
08-17 1248
.
Codeforces Global Round 10 A. Omkar and Password(思维)
give it a try
08-17 297
题目传送 题意: 给你一个n大小的数组，你每次可以合并俩个不同的数，问最后你能把数组压缩到的最小长度是多少? 思路: 只有1和n的区别。 什么时候为n呢? 当所有数都是一样的时候，我们不能进行合并操作，如 5 5 5，那么长度一定只能是n 什么时候为1呢? 只要一个数组中有俩个数不同，那么一定可以合并到只有一个数，如何证明? 证明: 既然有不同的数，那么数组中肯定有一个最大值，和一个最小值，且最大值与最小值不等。那么我就先让目前的最大值和最小值合并，就会又形成一个最大值，那么这个最大值现在在数组中肯定是唯一
Codeforces Global Round 10——A.B！.C
Celavia_yu的博客
08-17 204
Codeforces Global Round 10 A. Omkar and Password 题意：t组输入，每组n个数，数组a，可进行操作：相邻的两个值不同，则可以相加并替换掉这相邻的两个值，问最后数组剩余的长度最小值。 思路：只要数组里有超过两个不相同的数，就是可以相加得到最后只剩一个数。否则就是全部都相同的值，直接输出n。 代码 #include<bits/stdc++.h> using namespace std; int T,n; int a[200005]; map<int
Codeforces Global Round 9 A~D题解
Sivannn的博客
07-05 597
传送门 A.Sign FlippingB.Neighbor GridC.Element ExterminationD.Replace by MEX A.Sign Flipping        题意：给一个包含nnn个整数的数组，可以随意改变他们的正负号使得至少有n−12\frac{n-1}{2}2n−1​个相邻数字的差≥0\ge0≥0，且至少有n−12\frac{n-1}{2}2n−1​个相邻数字的差≤0\leq0≤0。  
Codeforces Global Round 10 A~D
wait
08-20 195
A - Omkar and Password 给一个序列，每次操作可以合并两个相邻但不相等的数，问要想把序列变成无法继续操作的序列，至少需要操作几次； 思路就是 序列中的每一个凹点都要变成和他距离最近的凸点一样高，并且凹点要在凸点的右侧，相当于存在 a[i] <a[i-1] 的话，加上两者的差即可； #include <bits/stdc++.h> using namespace std; const int N=2e5+7; int a[N]; int main() { i..
Codeforces Global Round 9
学习
07-07 204
转载自11D_Beyonder’s Blog A. Sign Flipping ↬\looparrowright↬   You are given n integers a1,a2,⋯ ,ana_1,a_2,\cdots,a_na1​,a2​,⋯,an​, where nnn is odd. You are allowed to flip the sign of some (possibly all or none) of them. You wish to perform these flips in s
Codeforces Global Round 10 B. Omkar and Infinity Clock(数学)
give it a try
08-17 192
题目传送 题意: 给你一个大小为n的数组a，还有一个正整数k，问进行k次操作后，数组是什么样，一次操作:对于每一个位置i 用数组中的最大值-ai替换 思路: 现在的数组中肯定是有一个最大值的，那么在一次操作后，Max(最大值)的位置一定会变成0，然后又会形成一个新的最大值，此时数组中肯定有Max和0的存在，然后进行操作后，Max变成0，0变成Max，继续下去这就是一个循环。 例:5 -1 4 2 0 第一次变0 6 1 3 5 第二次变6 0 5 3 1 第三次变0 6 1 3 5 … 这就是一个循环 AC
Codeforces Global Round 10 题解
忘梦心的博客
08-17 760
A. Omkar and Password 查看题解 数学
Codeforces Global Round 7 （A~D）
wait
03-20 422
昨晚没报上名导致没打，不过我这菜鸡，打不打貌似都一样...... A：Bad Ugly Numbers 题意：让你找出来一个n位数s，对于s的每一位，s都不是其倍数，并且不含0； 找到特殊组合即可；我找的2333333....... #include <bits/stdc++.h> using namespace std; int main() { int t,n; ci...
题解 合并 union
weixin_30488313的博客
03-26 347
合并 union Description 给出一个 1 ∼ N 的序列 A ( A 1 , A 2 , ..., A N ) 。你每次可以将两个相邻的元素合并，合并后的元素权值即为 这两个元素的权值之和。求将 A 变为一个非降序列，最少需要多少步操作。 Input 输入的第一行一个整数 N ( N ≤ 5000) 。 接下来一行 N 个整数，描述序列 A 。保证序列 A 中的每个元素的值不超过 1...
Codeforces Global Round 10 C. Omkar and Waterslide
ACkingdom的博客
08-18 191
题目链接 题意： 每次操作可以使得一个非递减区间全部++，问你最少操作几次可以使得数组递增。 思路： 我们只需要让每一个递增的开头都大于上一个递增的结尾即可，因为我们每次操作都可以将这个递增结尾之后的所有数都++，这样不会影响后面的判断，也不会多++。所以具体操作就是遍历然后遇到递减的情况就将结果加上s[i-1]-s[i]。 代码： #include<bits/stdc++.h> #define int long long #define IOS ios::sync_with_stdio(fal
1.将数组变成非递减数组的最少操作2.每日的任务数
blue‘s blog
09-23 1808
2.输入： 5 #接下来有n个任务， 2 3 5 #有2个前置任务分别为任务3，5；也就是说这第1个任务完成的前提是任务3，5完成 1 4 #第2个任务有1个前置任务为任务4 2 2 5 0 1 4 输出： 5 0 0 0 0 #输出第i天应该做的任务数量 【分析】利用追溯法。 res=[0 for i in range(N)] for i in range(N): ans=[i+...
力扣小白刷题之665题非递减序列
weixin_43525710的博客
05-01 227
题目描述 给定一个长度为 n (1 <= n <= 10 ^4) 的数组，在最多只修改一个元素的情况下，该数组能否变成一个非递减数列。 非递减数列：对于数组中所有的 i (1 <= i <= n)，总满足 array[i] <= array[i + 1]。 思路 在出现 nums[i] < nums[i - 1]时，需要考虑的是应该修改数组的哪个数，使得本次修改...
minishell脚本
最新发布
08-09
代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值