Codeforces Round 805 (Div. 3)

最新推荐文章于 2024-06-01 18:28:10 发布
最新推荐文章于 2024-06-01 18:28:10 发布
阅读量746 收藏 27
点赞数 21
分类专栏： codeforce 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74911187/article/details/134994970
版权

目录

A.Round Down the Price

B. Polycarp Writes a String from Memory

C. Train and Queries

D. Not a Cheap String

E. Split Into Two Sets

F. Equate Multisets

G1&&G2. Passable Paths (hard version)

A.Round Down the Price

按题意找到比当前数小的最大的10的整数幂的数，然后差值即为答案，我这里写复杂了，用的字符串，记得要考虑前导0

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;
    cin>>t;
    while(t--)
    {
        string s;cin>>s;
        string s1;
        if(s[0]=='1')s1=s.substr(1);
        else 
        {
            int ch=(s[0]-'1');
            s1=to_string(ch),s1+=s.substr(1);
        }
        int cnt=0;
        for(int i=0;i<s1.size();i++)if(s1[i]=='0')cnt++;
        if(s1.size()==cnt)cout<<0<<"\n";
        else 
        {
            for(int i=0;i<s1.size();i++)
                if(s1[i]!='0')
                {
                    cout<<s1.substr(i)<<"\n";
                    break;
                }
        }
    }
    return 0;
}

B. Polycarp Writes a String from Memory

题目要求我们每次只能删除3种字母，用map记录下来即可

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;cin>>t;
    while(t--)
    {
        string str;cin>>str;
        map<char,int>mp;
        int cnt=0,day=0;
        for(int i=0;i<str.size();i++)
        {
            if(!mp.count(str[i]))
            {
                cnt++;
                mp[str[i]]++;
            }
            if(cnt==3)
            {
                int r=i;
                while(r<str.size()&&mp[str[r]])r++;
                i=max(i,r-1);
                cnt=0;
                mp.clear();day++;
            }
        }
        if(!mp.empty())day++;
        cout<<day<<"\n";
    }
    return 0;
}

C. Train and Queries

题目大意：给定一个序列，然后每次询问给定两个数x，y，问序列中x后面是否有y。

思路：因为一个数可能出现多次，因此我们要存下来每个数出现的位置，并且记录下来每个数第一次出现的位置，最后二分查找即可。最后要注意一下，因为数可能很大，所以要离散化

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;cin>>t;
    while(t--)
    {
        int n,q;cin>>n>>q;
        vector<int>a(n);
        vector<int>p[n];
        map<int,int>mp,mp1;
        
        int idx=0;
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
            if(!mp1.count(a[i]))mp1[a[i]]=i;//记录下来每个数第一次出现的位置

            if(!mp.count(a[i]))mp[a[i]]=idx++;//离散化，给每个数编号
            p[mp[a[i]]].push_back(i);//记录下来每个数出现的位置
        }
        while(q--)
        {
            int x,y;
            cin>>x>>y;
            if(!mp.count(x)||!mp.count(y))
            {
                cout<<"NO"<<"\n";
                continue;
            }
            int id=mp1[x];
            auto it=lower_bound(p[mp[y]].begin(),p[mp[y]].end(),id);
            if(it!=p[mp[y]].end())cout<<"YES"<<"\n";
            else cout<<"NO"<<"\n";
        }

    }
    return 0;
}

D. Not a Cheap String

题目大意：给定一个字符串，字符串的权值等于每个字母在字母表中的位置的总和，例如a的权值是1，b的权值是2 ，字符串ab的权值就是1+2=3.再给定一个整数k，要求删除尽量少的字符，使得字符串的权值小于等于整数k。

思路：我们可以记录下来每一个字符出现的位置，依次遍历删除字符z到a，删除后的权值是否满足条件，删除的位置标记下来即可。

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;cin>>t;
    while(t--)
    {
        string s;cin>>s;
        int q;cin>>q;

        int len=s.size();
        vector<bool>st(len,0),st1(26,0);
        vector<int>v[26];
        int  sum=0;
        for(int i=0;i<len;i++)
        {
            sum+=(s[i]-'a')+1;
            v[s[i]-'a'].push_back(i);
        }
        if(sum<=q)
        {
            cout<<s<<"\n";
            continue;
        }
        for(int i=25;i>=0;i--)
        {
            if(sum<=q)break;
            if(v[i].size())
            {
                if(sum-(v[i].size()*(i+1))>=q)sum-=(v[i].size()*(i+1)),st1[i]=1;//表示字符（‘a'+i)整个都可以删去
                else
                {
                    for(int j=0;j<v[i].size();j++)
                    {
                        sum-=(i+1);
                        st[v[i][j]]=1;//表示字符（'a'+i)的第j个位置可以删去
                        if(sum<=q)break;
                    }
                }
            }
        }
        for(int i=0;i<len;i++)
        {
            if(st1[s[i]-'a']||st[i])continue;
            cout<<s[i];
        }
        cout<<"\n";
    }
    return 0;
}

E. Split Into Two Sets

题目大意：给定n个多米诺骨牌，每张骨牌上面有两个数，要求将所有的骨牌分成两堆，使得每堆中的数字不重复。

思路：这题可以用二分图匹配做，如果一个数出现了三次及以上，那么一定不满足题意，如果一张骨牌上的两个数一样，那么也一定不满足题意。如果一个数只出现过一次，那我们就不用管它，如果一个数出现了两次，那么我就用一条边连接这两个骨牌，表示这两张牌不能分到一堆去，最后做一个二分图匹配，如果能成功匹配，说明满足题意，否则不满足

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <set>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 2e5 + 10,M=2*N;

int n;
int h[N],e[M],ne[M],idx;
int c[N];
vector<int>st[N];

bool dfs(int u,int color)
{
    c[u]=color;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        
        if(!c[j])
        {
            if(!dfs(j,3-color))return false;
        }
        else if(c[j]==color)return false;
    }
    return true;
}
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=0;i<=n;i++)h[i]=-1,c[i]=0,st[i].clear();
        idx=0;
        
        bool ok=1;
        for(int i=1;i<=n;i++)
        {
            int a,b;
            cin>>a>>b;
            if(a==b)ok=0;

            st[a].push_back(i);st[b].push_back(i);
            if(st[a].size()>2||st[b].size()>2)ok=0;
        }        

        if(!ok)
        {
            cout<<"NO"<<"\n";
            continue;
        }

        set<pii>s;
        for(int i=1;i<=n;i++)
        {
           if(st[i].size()==2)
           {
                add(st[i][0],st[i][1]);
                add(st[i][1],st[i][0]);
           }
        }

        for(int i=1;i<=n;i++)
        {
            if(!c[i])
            {
                if(!dfs(i,1))
                {
                    ok=0;
                    break;
                }
            }
        }
        if(ok)cout<<"YES"<<"\n";
        else cout<<"NO"<<"\n";
    }
    return 0;
}

F. Equate Multisets

贪心

题目大意：给定两个数组a和b，可以在b数组进行两种操作，一种是将b中的任意一个元素变大两倍即×2，另一种是/2，可以进行任意次数的操作，判断能否操作使得a和b相等

思路：其实我们可以用操作1操作数组a，因为假设a=10，b=5，a/2==b*2，因此我们可以将a数组中所有能整除2的数一直整除到不能整除，直至变成一个奇数，这样子a中只有奇数了，那么对于b数组*2的操作就没用了，因为一个数*2是偶数，因此，对于b中的每个数，我们可以首先判断在a中是否有，如果没有的话，我们可以一直整除，直至到1，判断是否a中存在整个数，如果不存在说明不满足题意，如果所有数都可以操作后使得a和b相等， 那么就满足题意

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 1e5 + 10;

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;
    cin>>t;
    while(t--)
    {
        int n;cin>>n;

        bool ok=1;
        map<int,int>mp;
        for(int i=0;i<n;i++)
        {
            int x;cin>>x;
            while(x%2==0)x/=2;
            mp[x]++;
        }
        for(int i=0;i<n;i++)
        {
            int x;cin>>x;
            while(x%2==0)x/=2;
            while(x!=1&&mp[x]==0)x/=2;
            if(mp[x]==0)ok=0;
            else mp[x]--;
        }
        if(ok)cout<<"YES"<<"\n";
        else cout<<"NO"<<"\n";
    }
    return 0;
}

G1&&G2. Passable Paths (hard version)

lca

题目大意：给定一棵树，然后给定q个询问，对于每个询问，给定k个数，判断这k个数在给定的树中是否在一条链上。

思路：对于给定的k个数，我们首先找到两个端点t1，t2，然后找到两个端点的lca（t1,t2)=r,那么对于给定的k个数中的其他数p，要么在t1到r的路径上，要么在t2到r的路径上，如果不在其中任何一条路径上，说明p跟t1和t2不在一条链上，那么如果找到这两个端点呢，对于t1，我们可以让其等于深度最深的节点，对于t2，我们可以让其为跟t1不在一个子树且深度最深的节点，即要满足lca（t1，t2）！=t2，如果找不到满足条件的t2，说明在一条链上

代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int N = 2e5 + 10,M=2*N;

int n;
int h[N],e[M],ne[M],idx;
int depth[N],fa[N][20];
int q[N],p[N];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void bfs()
{
    int hh=0,tt=0;
    q[0]=1;depth[0]=0,depth[1]=1;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(depth[j]>depth[t]+1)
            {
                depth[j]=depth[t]+1;
                q[++tt]=j;
                fa[j][0]=t;
                for(int k=1;k<=18;k++)
                    fa[j][k]=fa[fa[j][k-1]][k-1];
            }
        }
    }
}
int lca(int a,int b)
{
    if(depth[a]<depth[b])swap(a,b);
    for(int k=18;k>=0;k--)
        if(depth[fa[a][k]]>=depth[b])
            a=fa[a][k];
    if(a==b)return a;
    for(int k=18;k>=0;k--)
        if(fa[a][k]!=fa[b][k])
        {
            a=fa[a][k];
            b=fa[b][k];
        }
    return fa[a][0];
}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    cin>>n;
    for(int i=0;i<=n;i++)h[i]=-1,depth[i]=0x3f3f3f3f;
    idx=0;
    for(int i=0;i<n-1;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);add(b,a);
    }
    bfs();

    int q;cin>>q;
    while(q--)
    {
        int k;cin>>k;
        for(int i=0;i<k;i++)cin>>p[i];

        int t1=p[0],t2=-1;
        for(int i=1;i<k;i++)
            if(depth[p[i]]>=depth[t1])t1=p[i];
        for(int i=0;i<k;i++)
        {
            if(p[i]!=t1&&lca(p[i],t1)!=p[i])
            {
                if((t2==-1)||(depth[p[i]]>=depth[t2]))
                    t2=p[i];
            }
        }

        if(t2==-1)
        {
            cout<<"YES"<<"\n";
            continue;
        }
        bool ok=1;
        for(int i=0;i<k;i++)
        {
            int x=p[i];
            int r=lca(t1,t2);
            int l1=lca(p[i],t1);
            int r1=lca(p[i],t2);
            if(!((l1==p[i]&&r1==r)||(l1==r&&r1==p[i])))
            {
                ok=0;
                break;
            }
        }
        if(ok)cout<<"YES"<<"\n";
        else cout<<"NO"<<"\n";
    }
    return 0;
}

m0_74911187
关注
  • 21
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m ...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round 905 (Div. 3)
maisui12138的博客
10-23 926
思路：若最大的左边界大于最小的右边界，则存在两线段不相交，set会自动去重，需要用数据结构里的multiset来实现，存入每段线段的两边界，根据first元素自动排序，开两个set，一个存入[l,r]，一个存入[r,l]思路：找到每个元素第一次出现和最后一次出现的位置，每出现第一次出现的元素时，记录，每出现最后一次出现的元素时，便可以与前面第一次出现的元素组成唯一的子数组。题意：给出a数组的n-1个元素，b数组的n个元素，a[1] = 1，删除ab中的元素使排序后的a[i] < b[i]，最少删除几次。
Codeforces Round 946 (Div. 3)
gege_0606的博客
05-21 938
З手机桌面- A - Codeforces。
Codeforces Round 946 (Div. 3)Codeforces Round 946 (Div. 3) 动态规划dp 01背包
JK01WYX的博客
05-22 202
而总钱数我们是可以根据天数 j * 工资 x 来求出 ， 那么就足以判断在这个状态下是否有足够钱可以购买这个商品了。那么 i - h[ j ] 就是买这个商品 j 前的总价值 ，dp[ i - h[ j ] ]就是。一共 m 天，每天都有一个商品，价格 c[ i ]，价值 h[ i ]。其实我们可以问题分离，先把所有最优状态求出来，然后检查是否可行即可。dp[ i ] 表示 购买价值到 i 时，消耗的最少钱数。本题就是在01背包上限制了个我们有的钱数。从第二天开始每天加 x 块钱。问最后最多买多少h。
Codeforces Round 913 (Div. 3)
maisui12138的博客
12-06 611
题意：游戏从0开始移动，有n段区间，每次移动最多不超过k的单位距离，需要移动n次，第i次移动必须在第i个区间内，最终需要到达第n个区间为游戏胜利，游戏胜利k值最小是多少。思路：记录数量最多的字符数量，若大于全部字符的一半，则最少剩余(mx - (n - mx))个字符，即最多字符的数量减去其他字符数量；题意：给出一个字符串，相邻字符不同可以删除，删除后剩下的字符按原顺序拼接，操作可以进行无数次，字符串最少剩余多少。思路：二分，每次记录当前最近/最远可移动到的距离，即最大的左边界和最小的右边界。
Codeforces Round 874 (Div. 3)
指针不指南吗的博客
05-21 1089
div 3 的前三道签到题，我太菜了
Codeforces Round 925 (Div. 3)
maisui12138的博客
02-14 2030
题意：初始可能会有一个排序序列代表n个用户，用户会发送这个序列，发送的时候把自己调到第一个，即在原序列的基础上，每个用户发送的序列自己都是在第一位的，通过k名用户发送的序列，判断是否可能存在一个初始的序列。思路：注意只能操作一次，那么就仨情况了，前半，后半，中间，记录开头连续相同的数量，和结尾连续相同的数量，取最大，若首尾相等则相加，答案则为除了这些相等的头尾的其余元素。题意：通过一次操作，操作为选择任意长度区间变为同一个数，将长度为n的数组a的所有元素相同，最小化区间的元素数量。
Codeforces Round 871 (Div. 4)
m0_65907991的博客
05-07 821
思路：先求出图的最长直经，找到直径的两个端点，和直径长度。直径的中点就是根节点，它的度数就是。看每本书都有对应的代价，求学会两种技能的最小代价。，可以用二分求出它所在的层数的上一层是第几层，令其为。然后就可以分3种情况得到直接位于它上方的部分的值。位于当前层的第一个，直接在其上方的部分就一个，值为。个变量维护三种类型各自的最小代价，最后得到答案。位于当前层最后一个，和第一种类似，其值为。，且3的个数大于2的个数就有解。题意：有一个图，其根节点直接与。，随便找个根节点直接相邻的节点。，直接在其上方的有两个。
Codeforces Round 915 (Div. 2)
Lanthamum的博客
12-16 515
【代码】Codeforces Round 915 (Div. 2)
Codeforces Round 860 (Div. 2)题解
qq_60653991的博客
03-27 487
比如我现在是提供三组数据：1 2 3 4。
Codeforces Round 918 (Div. 4)（AK）
weixin_61825750的博客
12-29 2643
A、模拟B、模拟C、模拟D、模拟E、思维，前缀和F、思维、逆序对G、最短路
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
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 #629 (Div. 3) B. K-th Beautiful String
01-03
B. K-th Beautiful String 题目链接-B. K-th Beautiful String 题目大意 长度为n的字符串包含n−2n−2n−2个aaa和222个bbb，求按照字典序排列输出第kkk个字符串 解题思路 第一个bbb在倒数第二位有1个字符串，在...
C++：round函数用法
Solititude的博客
05-28 373
C++：round函数用法
c++ string模拟实现
最新发布
2302_81705247的博客
06-01 568
模拟实现string类，里面包含四个成员变量，第一个是指向字符数组的指针，第二个变量是目前存放了多少个字符，第三个变量为这个字符数组的容量的大小。最后一个为静态成员变量npos。注意：一个修饰的成员变量可以在类里面初始化（三者缺一不可），而其他成员变量，要声明定义分离，类中声明，类外定义。char* _str;
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 846
string类各函数接口。
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 345
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
Codeforces Round 894 (Div. 3)
08-29
- *3* [Codeforces Round 894 (Div. 3)A~E题解](https://blog.csdn.net/gyeolhada/article/details/132491891)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值