2022牛客寒假算法基础集训营1

最新推荐文章于 2022-01-26 00:18:29 发布
最新推荐文章于 2022-01-26 00:18:29 发布
阅读量105 收藏
点赞数 2
分类专栏： 牛客 训练 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51354600/article/details/122691655
版权

2022牛客寒假算法基础集训营1

A.九小时九个人九扇门

分析：

  • 要先发现一个特点：对于多个数的合并，先求和再求根，与先分别求根 再求根的和 的根，效果是一样的，

    举个栗子：17+23+79=119=2，8+5+7=20=2

    因此，先分别将n个数求取根，就变成n个1~9的数了

  • 然后就是类似01背包的动态转移

    d p [ i ] [ c h a n g e ( x + j ) ] + = d p [ i − 1 ] [ j ] dp[i][change(x+j)]+=dp[i-1][j] dp[i][change(x+j)]+=dp[i−1][j]

  • 转换也可以不用递归来写，模9取余也可以，注意一点，为9的倍数时，是余0的就行

#include <bits/stdc++.h>
#define int long long 
using namespace std;

const int N=1e5+5, mo=998244353;
int change(int x)
{
    while(x>9)
    {
        int t=x,s=0;
        while(t)
        {
            s+=t%10;
            t/=10;
        }
        x=s;
    }
    return x;
}
int dp[N][11];
void solve()
{
    int n;
    cin>>n;
    dp[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        for(int j=0;j<=9;j++)
        {
            dp[i][j]=(dp[i][j]+dp[i-1][j])%mo;
            int k=change(x+j); // =(x+j)%9;
            dp[i][k]=(dp[i][k]+dp[i-1][j])%mo;
        }
    }
    for(int i=1;i<=9;i++) cout<<dp[n][i]<<' ';
    cout<<endl;
} 
signed main()
{
	int T=1;		
	//cin>>T;
    while(T--) solve();
}

B.炸鸡块君与FIFA22

分析：（待补充）

C.Baby’s first attempt on CPU

分析：

  • 将两句有关联的语句隔开（即使两者之间的语句数量至少为3）
  • 模拟，d[i]表示当前语句是第几条（加上空白的），与d[i-j]+3比较取大值
#include <bits/stdc++.h>
#define int long long 
using namespace std;

const int N=1005;
int d[N];
void solve()
{
    int n;
    cin>>n;
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        d[i]=d[i-1];
        for(int j=1;j<=3;j++)
        {
            int x; cin>>x;
            if(x) d[i]=max(d[i],d[i-j]+3);
        }
        d[i]++;
    }
    cout<<d[n]-n<<endl;
} 
signed main()
{
	int T=1;		
	//cin>>T;
    while(T--) solve();
}

D.牛牛做数论

分析：

  • 欧拉函数： φ ( n ) = n × ∏ i = 1 s p i − 1 p i \varphi(n) = n \times \prod_{i = 1}^s{\dfrac{p_i - 1}{p_i}} φ(n)=n×∏i=1s​pi​pi​−1​

    故 H ( x ) = ∏ i = 1 s p i − 1 p i H(x)=\prod_{i=1}^s\frac{p_i-1}{p_i} H(x)=∏i=1s​pi​pi​−1​

  • 后者即求范围内最大的质数

  • 前者即求不同质因子数量最多的数，且要求最小（即 2 ∗ 3 ∗ 5 ∗ 7 ∗ . . . 2*3*5*7*... 2∗3∗5∗7∗...）

#include <bits/stdc++.h>
#define int long long 
using namespace std;

const int N=1e6+5;
int a[N],b[N],s[N];
void solve()
{
    int n;
    cin>>n;
    int r=n,fg=1;
    while(fg)
    {
        fg=0;
        for(int i=2;i<=sqrt(r);i++)
        {
            if(r%i==0)
            {
                fg=1;
                r--;
                break;
            }
        }
    }
    int tot=0;
    for(int i=2;i<=1000;i++) 
    {
        int fg=1;
        for(int j=2;j<=sqrt(i);j++)
        {
            if(i%j==0) 
            {
                fg=0;
                break;
            }
        }
        if(fg) b[++tot]=i;
    }
    int ans=1;
    for(int i=1;i<=tot;i++)
    {
        if(ans*b[i]<=n) ans*=b[i];
        else break;
    }
    if(n==1) cout<<-1<<endl;
    else cout<<ans<<' '<<r<<endl;
} 
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}

E.炸鸡块君的高中回忆

  • 签到题
#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
char s[N];
void solve()
{
    int n,m;
    cin>>n>>m;
    if(m==1)
    {
        if(n==1) cout<<1<<endl;
        else cout<<-1<<endl;
    }
    else 
    {
        int ans=1+(n-m)/(m-1)+((n-m)%(m-1)!=0);
        cout<<2*ans-1<<endl;
    }
}
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}

F.中位数切分

分析：

  • emmm… 这题我是读假题了，然后一眼看出来（还刚好和正确结论撞上了）

    我所理解的题意：将序列划分成若干段（可以不连续），那不就是将所有的"<m的数"全部放在一个序列里，再用">=m"的去配成一个合法的，然后剩下的">m"的全部单独拎出来即可、

  • 以下是错误理解，但是 A 了的代码

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
int a[N];
void solve()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+1+n);
    int p=lower_bound(a+1,a+1+n,m)-a;
    if(n-p+1<=p-1) cout<<-1<<endl;
    else 
    {
        cout<<1+(n-p-p+1)<<endl;
    }
} 
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}

正解

  • (假设"<m"的个数为a，">=m"的个数为b)

  • 对于某一段连续的序列，要使该序列合法，则 b > = a + 1 b>=a+1 b>=a+1

    根据这个结论，去划分，使得每个单独序列的 b ‘ − a ‘ = 1 b^{`}-a^{`}=1 b‘−a‘=1

    这样， a n s = b − a ans=b-a ans=b−a

 #include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
int a[N];
void solve()
{
    int n,m;
    cin>>n>>m;
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        if(x<m) cnt++;
    }
    int ans=n-2*cnt;
    if(ans>0) cout<<ans<<endl;
    else cout<<-1<<endl;
} 
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}

G.ACM is all you need

分析：

  • map 遍历，分类讨论

  • 若对 a [ i ] ( 1 < i < n ) a[i](1<i<n) a[i](1<i<n) 展开讨论，会有四种情况

    • a [ i ] < a [ i + 1 ]   a n d   a [ i ] < a [ i − 1 ] a[i]<a[i+1] \ and\ a[i]<a[i-1] a[i]<a[i+1] and a[i]<a[i−1]：会对 ans 贡献1，当b比某个值还要大时，会对 ans 贡献-1
    • a [ i ] > a [ i + 1 ]   a n d   a [ i ] > a [ i − 1 ] a[i]>a[i+1] \ and\ a[i]>a[i-1] a[i]>a[i+1] and a[i]>a[i−1]：当b大于某个值时，会对 ans 贡献1
    • a [ i ] > a [ i + 1 ]   a n d   a [ i ] < a [ i − 1 ] a[i]>a[i+1] \ and\ a[i]<a[i-1] a[i]>a[i+1] and a[i]<a[i−1]：当b大于某个值会对 ans 贡献1，再大一些，大于第二个值时，会贡献-1
    • a [ i ] < a [ i + 1 ]   a n d   a [ i ] > a [ i − 1 ] a[i]<a[i+1] \ and\ a[i]>a[i-1] a[i]<a[i+1] and a[i]>a[i−1]：同（3）

  • 最后的贡献，就是“某个值”从小到大，贡献值的前缀和

  • 每种情况的“某个值”，可以通过画图或举例来求出具体如何表示

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
int a[N];
void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    int ans=0;
    map <int,int> mp;
    for(int i=2;i<n;i++)
    {
        if(a[i]<a[i+1] && a[i]<a[i-1])
        {
            ans++;
            int mn=min(a[i-1],a[i+1]);
            mp[(a[i]+mn+1)/2]++;
        }
        else if(a[i]>a[i+1] && a[i]>a[i-1])
        {
            int mx=max(a[i+1],a[i-1]);
            mp[(a[i]+mx)/2+1]--;
        }
        else if(a[i]>a[i+1] && a[i]<a[i-1])
        {
            mp[(a[i]+a[i+1])/2+1]--;
            mp[(a[i]+a[i-1]+1)/2]++;
        }
        else if(a[i]>a[i-1] && a[i]<a[i+1])
        {
            mp[(a[i]+a[i-1])/2+1]--;
            mp[(a[i]+a[i+1]+1)/2]++;
        }
    }
    int now=0,mx=0;
    for(auto it : mp)//遍历
    {
        now+=it.second;
        mx=max(now,mx);
    }
    cout<<ans-mx<<endl;
}
signed main()
{
    int t=1;
    cin>>t;
    while(t--) solve();
}

H.牛牛看云

分析：

  • 二分，前缀和，绝对值运算

  • 直接计算 O ( n 2 ) O(n^2) O(n2)，炸了，考虑优化

  • 首先，是去绝对值，同时考虑 a i , a j a_i,a_j ai​,aj​ 太头疼，可以通过一步变换，将两者分离

    分两种情况：

    • a i + a j − 1000 > = 0 a_i+a_j-1000>=0 ai​+aj​−1000>=0： a n s + = a j − ( 1000 − a i ) ans+=a_j-(1000-a_i) ans+=aj​−(1000−ai​)
    • a i + a j − 1000 < 0 a_i+a_j-1000<0 ai​+aj​−1000<0： a n s + = ( 1000 − a i ) − a j ans+=(1000-a_i)-a_j ans+=(1000−ai​)−aj​

    令 1000 − a i = d 1000-a_i=d 1000−ai​=d , 那么对于这组序列，若从小到大排序（排序之后显然不会影响最后结果），并二分找到第一个">d" 的数 a [ p ] a[p] a[p]，根据上述两种情况，便可得到对ans的贡献：

    a n s + = ( p − i ) ∗ d − ( s [ p − 1 ] − s [ i − 1 ] ) + s [ n ] − s [ p − 1 ] − ( n − p + 1 ) ∗ d ; ans+=(p-i)*d-(s[p-1]-s[i-1])+s[n]-s[p-1]-(n-p+1)*d; ans+=(p−i)∗d−(s[p−1]−s[i−1])+s[n]−s[p−1]−(n−p+1)∗d;

#include <bits/stdc++.h>
#define int long long 
using namespace std;

const int N=1e6+5;
int a[N],b[N],s[N];
void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++) s[i]=s[i-1]+a[i];
    int ans=0; 
    for(int i=1;i<=n;i++)
    {
        int d=1000-a[i];
        int p=upper_bound(a+i,a+1+n,d)-a;
        ans+=(p-i)*d-(s[p-1]-s[i-1])+s[n]-s[p-1]-(n-p+1)*d;
    }
    cout<<ans<<endl;
} 
signed main()
{
	int T;		
	//cin>>T;
    T=1;
	while(T--) solve();
}

暴力求解

  • 赛后才发现 0 = < a i < = 1000 0=<a_i<=1000 0=<ai​<=1000， 那就可以直接记录个数，直接暴力算贡献
#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N=1e6+5;
int b[N];
void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        int x; cin>>x;
        b[x]++;
    }
    int ans=0;
    for(int i=0;i<=1000;i++)
    {
        for(int j=i;j<=1000;j++)
        {
            if(i==j) ans+=b[i]*(b[i]+1)/2*abs(i+j-1000);
            else ans+=b[i]*b[j]*abs(i+j-1000);      
        }
    }
    cout<<ans<<endl;
}
signed main()
{
    int T=1;
    //cin>>T;
    while(T--) solve();
}

I.B站与各唱各的

分析：

  • 一句歌词失败的概率为 2 2 n \frac{2}{2^n} 2n2​

    故期望为 m × ( 1 − 1 2 n − 1 ) m\times(1-\frac{1}{2^{n-1}}) m×(1−2n−11​)

#include <bits/stdc++.h>
#define int long long 
using namespace std;

const int N=1005,mo=1e9+7;
int ksm(int a,int b,int p)
{
    int ans=1;
    while(b)
    {
        if(b&1) ans=ans*a%p;
        a=a*a%p; b>>=1;
    }
    return ans;
}
void solve()
{
    int n,m;
    cin>>n>>m;
    int d=ksm(2,n-1,mo);
    int ans=m*(1+mo-ksm(d,mo-2,mo))%mo;
    cout<<ans<<endl;
} 
signed main()
{
	int T=1;		
	cin>>T;
    while(T--) solve();
}

J.小朋友做游戏

  • 签到题
#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
int a[N],b[N];
void solve()
{
    int n,m,k;
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=m;i++) cin>>b[i];
    sort(a+1,a+1+n);
    sort(b+1,b+1+m);
    int d=(k+1)/2;
    if(n<d ) 
    {
        cout<<-1<<endl;
    }
    else 
    {
        int ans=0,r=n;
        while(r>n-d) ans+=a[r], r--;
        int l=m,cnt=0;
        while(cnt++<k-d)
        {
            if(a[r]>b[l]) ans+=a[r], r--;
            else ans+=b[l], l--; 
        }
        cout<<ans<<endl;
    }
} 
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}

K. 冒险公社

题意：

  • 根据预测情况，求前 n 个岛最多的绿岛数

分析：

  • 没有思路的情况下，先想了一下暴力， O ( 3 n ) O(3^n) O(3n) 显然超时

    暴力枚举所有情况，每次都会考虑n个岛的具体颜色

    但实际上，对于每次预判我们只需要考虑当前岛和其前两个岛的颜色即可

    所以，考虑线性DP，枚举每三个岛的情况，记录状态，再状态转移即可

  • d p [ i ] [ y ] [ z ] dp[i][y][z] dp[i][y][z] 表示前 i 个岛，第i个岛颜色为z，第i-1个岛颜色为y的情况下，最多绿岛数，那么状态转移方程为，

    dp[i][y][z]=max(dp[y][z],dp[x][y]+(z==1));

    然后根据当前预测值分为三类情况考虑：（g表示三个岛绿岛数，r表示红岛数）

    • s[i]==‘R’：r>g 时才会进行状态转移

    • s[i]==‘G’：g>r 时，~~

    • s[i]‘B’：gr 时，~~

  • 坑点：最后答案为0时，也是合法情况，因此dp初值要赋为无穷小才能得到非法情况"-1"

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
char s[N];
int dp[N][5][5];
void solve()
{
    int n;
    cin>>n>>s+1;
    memset(dp,-0x3f,sizeof(dp));
    // 预处理
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            int g=(i==1)+(j==1), r=(i==2)+(j==2);
            dp[2][i][j]=g;
        }
    }
    for(int i=3;i<=n;i++)
    {
        for(int x=1;x<=3;x++)
            for(int y=1;y<=3;y++)
                for(int z=1;z<=3;z++)
                {
                    int g=(x==1)+(y==1)+(z==1), r=(x==2)+(y==2)+(z==2);
                    if((g==r && s[i]=='B') || (g>r && s[i]=='G') || (g<r && s[i]=='R'))
                    {
                        dp[i][y][z]=max(dp[i][y][z],dp[i-1][x][y]+(z==1));
                    }
                }
    }
    int ans=-0x3f3f3f3f;
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            ans=max(ans,dp[n][i][j]);
        }
    }
    if(ans>=0) cout<<ans<<endl;
    else cout<<-1<<endl;
}
signed main()
{
    int T=1;
    //cin>>T;
    while(T--) solve();
}

L.牛牛学走路

  • 签到题
#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
char s[N];
void solve()
{
    int n;
    cin>>n;
    cin>>s+1;
    double x=0,y=0,ans=0;
    for(int i=1;i<=n;i++)
    {
        if(s[i]=='U') y++;
        if(s[i]=='D') y--;  
        if(s[i]=='R') x++;
        if(s[i]=='L') x--;
        ans=max(ans,sqrt(x*x+y*y));
    }
    printf("%.12lf\n",ans);
}
signed main()
{
	int T;		
	cin>>T;
	while(T--) solve();
}
yezzz.
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2022牛客寒假算法基础集训营2
m0_58178876的博客
01-27 1101
2022牛客寒假算法基础集训营2题解
九小时九个人九扇门
eeeedew的博客
02-09 2010
链接：登录—专业IT笔试面试备考平台_牛客网 来源：牛客网 题目描述 在打越钢太郎的著名解谜游戏系列《极限脱出》的第一作《九小时九个人九扇门》中，有这样一个有趣的设定：游戏中，999位主人公被困在一座大型的豪华巨轮中，每个人手上都有一个奇怪的手表，手表上有一个数字，999个人的数字分别是1−91-91−9；在巨轮中，还有很多紧闭的数字门，每扇数字门上也有一个1−91-91−9的数字，要想打开数字门逃出生天，主角们必须要满足一个奇怪的条件： kkk个人能够打开门上数字为ddd的一扇数字门，当且仅.
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2020牛客暑期多校集训营第三场题解.pdf
01-20
题解
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客暑期多校集训营第五场题解.pdf
01-20
2020牛客暑期多校集训营第五场题解.pdf
2022/1/25-2022牛客寒假算法基础集训营1B-炸鸡块君与FIFA22(线段树)
weixin_55630352的博客
01-25 3081
题目描述 热爱足球（仅限游戏）的炸鸡块君最近购买了FIFA22，并且沉迷于FIFA22的Rivals排位上分。 在该排位系统中，每局游戏可能有胜利（用W表示）、失败（用L表示）、平局（用D表示）三种结果，胜利将使得排位分加一、失败使排位分减一、平局使排位分不变。特别地，该排位系统有着存档点机制，其可以简化的描述为：若你当前的排位分是3的整倍数（包括0倍），则若下一局游戏失败，你的排位分将不变（而不是减一）。 现在，给定一个游戏结果字符串和若干次询问，你需要回答这些询问。 每次询问格式为(l,r,s)，
2022牛客寒假算法基础集训营（一）1全部题解
quinn18的博客
01-25 903
文章目录A 九小时九个人九扇门 dpH 牛牛看云 思维F 中位数切分 思维I B站与各唱各的 数学D 牛牛做数论 数学B 炸鸡块君与FIFA22 倍增/分块/线段树K 冒险公社 dpG ACM is all you need总结 比赛链接 A 九小时九个人九扇门 dp 题目链接 题意： 一个数字的数字根是指：将该数字各数位上的数字相加得到一个新的数，直到得到的数字小于 101010 为止.。设置小于 101010 的数字，其数字根就为其本身。 kkk 个人能够打开门上数字为d的一扇数字门，当
2022年牛客寒假算法基础集训营第一场
qq_59726581的博客
01-26 126
因为笔者太菜了，所以不仅在比赛期间过题数不高，而且赛后补题也没补完，但是因为先总结一下自己补题和当时过题时的想法，所以写了这一篇。。。。其实主要给我自己看的。 A.九小时九个人九扇门 当时这一题比赛期间没写出来，主要是由于出现了一些小bug导致我输出的连样例都没过，因为太急躁了，所以没有继续做下去。先贴代码 #include<stdio.h> #include<iostream> #include<algorithm> using namespace std; l
牛客寒假训练营 1 E 炸鸡块君的高中回忆(模拟推公式)
qq12323qweeqwe的博客
01-25 234
由于有多组测试数组，直接模拟的话会超时，所以需要推出一个公式 首先模拟一下带入的过程 那么k次带入人数 a+(k-1)*(m-1)=s （1<=a<=m) 令 s-1=(a-1)+(k-1)*(m-1) 如果a==m，(s-1)/(m-1)=k次 由于最后一次不返回，只需要2k-1时间 如果a!=m， (s-1)/(m-1)=k-1次 由于最后一次不返回 ，此时只需要出去外面一次，即2k+1时间 综上所述，就可以处理能回来的情况了 此时还有不能回来的情况，...
2022牛客寒假算法基础集训营1 B.炸鸡块君与FIFA22 线段树
HeartFireY的博客
01-24 355
思路 主要针对”333的整倍数下一局不扣分“限制条件找思路。考虑维护三棵线段树，第一颗线段树表示取模为000时后对应分数操作，第二三棵类推。 然后只需要进行一个建树和一个单点查询的操作：注意在push_up的时候，合并左右区间的操作时，对右区间需要额外考虑左区间对分数的影响，也就是算出左区间影响后的分数再取对应操作。 另外，再查询时也需要考虑左区间加入后对右区间的影响。 Accepted Code #include <bits/stdc++.h> using namespace std; co
牛客竞赛算法入门班怎么样
最新发布
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：包括时间复杂度、空间复杂度、递归、排序算法等。 2. 数据结构：包括数组、链表、栈、队列、树、图等。 3. 常用算法：包括贪心算法、动态规划、回溯算法、分治算法等。 4. 算法竞赛技巧：包括如何优化算法、如何处理特殊情况、如何设计算法等。 5. 实战习题：提供大量的算法竞赛习题，帮助学员巩固所学知识并提高解题能力。 通过参加牛客竞赛算法入门班，学员可以系统地学习算法竞赛的基础知识和技巧，提高解题能力，并为参加算法竞赛打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yezzz.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值