2022牛客寒假算法基础集训营1(蒻蒻补题)

最新推荐文章于 2024-10-03 13:36:06 发布
最新推荐文章于 2024-10-03 13:36:06 发布
阅读量103 收藏
点赞数
分类专栏： 牛客 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51771856/article/details/123385716
版权
这篇博客探讨了动态规划在解决数论问题和区间更新查询中的应用，包括欧拉函数的计算、区间最值维护和逆元计算。同时介绍了如何使用线段树和前缀和等数据结构高效处理区间操作，以及在字符串处理和图形路径优化中的应用。
摘要由CSDN通过智能技术生成

A

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 998244353;
vector<int> a((int)2e6);
signed main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
        int num = a[i];
        int sum = 0;
        while (1)
        {
            while (num)
            {
                sum += num % 10;
                num /= 10;
            }
            if (sum < 10)
                break;
            num = sum;
            sum = 0;
        }
        a[i] = sum;
    }
    int ans[11] = {0};
    ans[0] = 1;
    for (int i = 0; i < n; i++)
    {
        vector<int> ve(11, 0);
        for (int j = 0; j <= 9; j++)
        {
            int u = a[i] + j;
            if (u>9) u = u%10+u/10;
            ve[u] = ans[j];
            ve[u] %= mod;
        }
        ve[a[i]]++;
        for (int j = 0; j <= 9; j++)
        {
            ans[j] += ve[j];
            ans[j] %= mod;
        }
    }
    for (int i = 1; i <= 9; i++)
    {
        cout << ans[i] << " ";
    }
}

B

st表的应用，st[k][i][j]表示从k初始值，i位置开始的2的j次方值

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int st[3][N][33];
char ch[N]; 
int n, q;
int mod(int x)
{
    return (x % 3 + 3) % 3;
}
int main()
{
    cin >> n >> q;
    scanf("%s", ch + 1);
    for (int j = 0; j <= 20; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            if (j == 0)
            {
                if (ch[i] == 'W')
                {
                    st[0][i][j] = st[1][i][j] = st[2][i][j] = 1;
                }
                if (ch[i] == 'L')
                {
                    st[0][i][j] = 0;
                    st[2][i][j] = st[1][i][j] = -1;
                }
                if (ch[i] == 'D')
                {
                    st[0][i][j] = st[1][i][j] = st[2][i][j] = 0;
                }
            }
            else
            {
                int p1 = i, p2 = i + (1 << (j - 1));
                if (p2 > n)
                {
                    st[0][p1][j] = st[0][p1][j - 1];
                    st[1][p1][j] = st[1][p1][j - 1];
                    st[2][p1][j] = st[2][p1][j - 1];
                }
                else
                {
                    st[0][p1][j] = st[0][p1][j - 1] + st[mod(0 + st[0][p1][j - 1])][p2][j - 1];
                    st[1][p1][j] = st[1][p1][j - 1] + st[mod(1 + st[1][p1][j - 1])][p2][j - 1];
                    st[2][p1][j] = st[2][p1][j - 1] + st[mod(2 + st[2][p1][j - 1])][p2][j - 1];
                }
            }
        }
    }
    int l, r, ans;
    for (int i = 0; i < q; i++)
    {
        scanf("%d%d%d", &l, &r, &ans);
        int pos = l;
        while (pos <= r)
        {
            int j = 0;
            while (pos + (1 << j) - 1 <= r)
                j++;
            j--;
            ans += st[ans % 3][pos][j];
            pos += (1 << j);
        }
        printf("%d\n", ans);
    }
    return 0;
}

C

#include <bits/stdc++.h>
using namespace std;
unordered_map<int,int>mp;
vector<pair<int,int> >ve;
int main()
{
    int n,x;
    cin>>n;
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=3;j++)
        {
            cin>>x;
            if (x==1)
            {
                ve.push_back({i-j,i});
            }
        }
    }
    sort(ve.begin(),ve.end());
    int m = ve.size();
    int res = 0;
    for (int i=m-1;i>=0;i--)
    {
        int a = ve[i].first;
        int b = ve[i].second;
        int cou = 0;
        int ncou = max(0,4-(b-a));
        for (int j=a;j<b;j++)
        {
            cou+=mp[j];
        }
        if (cou<ncou)
        {
            mp[a] += ncou-cou;
            res+=ncou-cou;
        }
    }
    cout<<res<<endl;
}

D

欧拉函数是小于x的整数中与x互质的数的个数，一般用φ(x)表示。特殊的，φ(1)=1。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll prime[20]={0,2,3,5,7,11,13,17,19,23,29,31,37,41};
ll n,t;
inline bool isP(int x){
    if(x<=3)    return true;
    for(int i=2;i*i<=n;i++){
        if(n%i==0)    return false;
    }
    return true;
}
int main(){
    cin>>t;
    while(t--){
        cin>>n;
        assert(n!=0);
        ll now=1,i=1;
        if(n==1){
            puts("-1");
            continue;
        }
        while(now*prime[i]<=n){
            now*=prime[i];
            i++;
        }
        printf("%lld ",now);
        while(!isP(n)){
            n--;
        }
        printf("%lld\n",n);
    }
    return 0;
}

E

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>n>>m;
        if (m==1)
        {
            if (n==1) cout<<1<<endl;
            else cout<<-1<<endl;
        }
        else 
        {
            int res = 1;
            int cou = 0;
            n-=m;
            m--;
            if (n%m) cou++;
            cou+=n/m;
            res = res+cou*2;
            cout<<res<<endl;
        }
    }
}

F

#include <bits/stdc++.h>
using namespace std;
vector<int> a((int)2e6), sum((int)2e6, 0);
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        stack<int> q;
        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
            if (a[i] < m)
                a[i] = -1;
            else
                a[i] = 1;
            sum[i] = a[i] + sum[i - 1];
        }
        int ff = 1;
        int res = 0;
        for (int i = 1; i <= n; i++)
        {
            res += a[i];
            if (res > 0)
            {
                q.push(res);
                res = 0;
            }
            else
            {
                while (!q.empty())
                {
                    int sum = q.top();
                    q.pop();
                    res += sum;
                    if (res > 0)
                    {
                        q.push(res);
                        res = 0;
                        break;
                    }
                }
            }
        }
        if (q.empty()) cout<<-1<<endl;
        else cout<<q.size()<<endl;
    }
}

G

map模拟区间
在这个区间里变换不会促成条件成立

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N];

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        map<int, int> mp;
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }
        int ans = 0;
        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;
    }
}

H

#include<bits/stdc++.h>
using namespace std;
vector<int>a((int)2e6);
vector<int>sum1((int)2e6,0),sum2((int)2e6,0);
int main()
{
    int n;
    cin>>n;
    for (int i=1;i<=n;i++)
    {
        cin>>a[i];
        a[i]-=500;
    }
    sort(a.begin()+1,a.begin()+n+1);
    for (int i = 1;i<=n;i++)
    {
        sum1[i] = sum1[i-1]+a[i];
    }
    for (int i=n;i>=1;i--)
    {
        sum2[i] = sum2[i+1]+a[i];
    }
    long long res = 0;
    for (int i=1;i<=n;i++)
    {
        int k = lower_bound(a.begin()+i,a.begin()+n+1,-a[i])-a.begin();
        if (k!=i) res+=abs(sum1[k-1]-sum1[i-1]+a[i]*(k-i));
        if (k<=n) res+=abs(sum2[k]+a[i]*(n-k+1));
    }
    cout<<res<<endl;
}

I

一道逆元问题
乘法逆元
Mod为质数时
a/b(mod) = a*b[m-2]

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int mod = 1e9 + 7;
int ksm(int a, int b)
{
    int ans = 1;
    for (; b; b >>= (int)1)
    {
        if (b & 1)
            ans = ans * a % mod;
        a = a * a % mod;
    }
    return ans;
}
int inv(int x)
{
    return ksm(x,mod-2);
}
signed main()
{
    int t,n,m;
    cin>>t;
    while (t--)
    {
        cin>>n>>m;
        int k = ksm(2,n);
        cout<<(((m*((k-2+mod)%mod))%mod)*inv(k))%mod<<endl;
    }
}

J

#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> a((int)2e6);
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int A, B, n;
        cin >> A >> B >> n;
        for (int i = 1; i <= A + B; ++i)
        {
            cin >> a[i].first;
            if (i <= A)
                a[i].second = 1; //安静
            else
                a[i].second = 0; //闹腾
        }
        int ff = 1;
        int cou2 = min(n / 2, B);
        sort(a.begin() + 1, a.begin() + 1 + A + B);
        int res = 0;
        int cou = 0;
        for (int i = A + B; i >= 1; i--)
        {
            if (a[i].second == 1)
            {
                res += a[i].first;
                cou++;
            }
            else
            {
                if (cou2 > 0)
                {
                    res += a[i].first;
                    cou++;
                    cou2--;
                }
            }
            if (cou==n) break;
        }
        if (cou==n) cout<<res<<endl;
        else cout<<-1<<endl;
    }
}

K

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define SZ(v) ((int)v.size())
#define fs first
#define sc second
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
int n;
// 0G 1B 2R
int dp[100010][27];
const int inf=-1e6;
char s[100010];
int cnt(int x){
    int g=(x%3==0)+(x/3%3==0)+(x/9%3==0);
    int r=(x%3==2)+(x/3%3==2)+(x/9%3==2);
    return g-r;
}
int main(){
    scanf("%d%s",&n,s+1);
    rep(i,0,n+5){
        rep(j,0,26)    dp[i][j]=inf;
    }
    rep(j,0,26){
        if(s[3]=='G'&&cnt(j)<=0)    continue;
        if(s[3]=='B'&&cnt(j)!=0)    continue;
        if(s[3]=='R'&&cnt(j)>=0)    continue;
        dp[3][j]=(j%3==0)+(j/3%3==0)+(j/9%3==0);
    }
    rep(i,4,n){
        rep(j,0,26){
            if(s[i]=='G'&&cnt(j)<=0)    continue;
            if(s[i]=='B'&&cnt(j)!=0)    continue;
            if(s[i]=='R'&&cnt(j)>=0)    continue;
            rep(k,0,26){
                if(k%3==j/3%3&&k/3%3==j/9%3){
                    dp[i][j]=max(dp[i][j],dp[i-1][k]+(j%3==0));
                }
            }
        }
    }
    int ans=inf;
    rep(j,0,26)    ans=max(ans,dp[n][j]);
    if(ans<0)    puts("-1");
    else    printf("%d\n",ans);
    return 0;
}

L

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        char ch[1010];
        cin>>ch+1;
        double x = 0.0,y = 0.0;
        double res = 0.0;
        for (int i=1;i<=n;i++)
        {
            if (ch[i]=='U')
            {
                y+=1.0;
            }
            else if (ch[i]=='D')
            {
                y-=1.0;
            }
            else if(ch[i]=='L')
            {
                x-=1.0;
            }
            else if (ch[i]=='R')
            {
                x+=1.0;
            }
            res = max(res,x*x+y*y);
        }
        res = sqrt(res);
        printf("%.12lf\n",res);
    }
}
卐邾翊
关注
专栏目录
2022牛客寒假算法基础集训营2
SecretMas的博客
03-07 371
A 小沙的炉石 题意： 给定n张进攻卡和m张回复卡，每次使用进攻卡会消耗一点法力值并造成一点基础伤害和累计的法术伤害，每次使用回复卡会回复一点法力值，每使用一张卡片后都会使累计的法术伤害+1。一开始，法力值只有一点，法力值无上限。给定血量x，回答是否可以“刚好斩杀”。 “刚好斩杀”：通过合理的使用卡牌方式，使血量恰好变为0。 涉及算法：二分，等差数列 观察到： 最少可使用1张攻击卡，最多可使用min(n,m + 1)张攻击卡。 当这局使用x张攻击卡时： 伤害最大化：先把所有的回复卡打完，再尽可能的打出最多的
2022牛客寒假算法基础集训营1
ygh2437068791的博客
12-29 441
2022牛客寒假算法基础集训营1，前几道简单中等题。
2022牛客寒假算法基础集训营1 H 牛牛看云
black_blue_lja的博客
01-25 1184
关于H，提供一个好像没什么人想的思路 因为题目要求的公式是形如： for (int i=1;i<=n;i++) for (int j=i;j<=n;j++) 的形式。（不妨叫他公式1） 一开始我想到排序+前缀和处理，因为我把这个公式看成了： for (int i=1;i<=n;i++) for (int j=1;j<=n;j++) 这样的形式。（不妨叫他公式2） 后来想了半天没想到题解里说的枚举1到1000，就回来想是不是能顺.
牛牛看云（2022牛客寒假算法基础集训营1）
m0_63492087的博客
01-24 626
题目传送门：牛牛看云 乍一看这道题，直接暴力二重循环（我不注意数据范围我该打），于是WA到怀疑人生 正解如下： 出题人炸鸡块君曰：本题没做出来的xdm要提高对数据范围的敏感程度~ 注意题中数据：整数n(3≤n≤1e6),而整数a(0≤a≤1000) 所以当n很大时，会出现很多重复的值，所以我们只需记录每个a出现的次数，然后直接循环枚举就好了 注意要用long long 其他注释都在代码里啦 #include <cstdio> #include <iostream>
2022牛客寒假算法基础集训营6（补题）
m0_62289613的博客
02-13 439
2022牛客寒假算法基础集训营6补题
2024牛客寒假算法基础集训营1
m0_73673533的博客
02-02 375
具体来说，我们枚举m的每一位为1的1，强制这一位为0，这样m被分为前后两部分，对于前面的部分一定要满足或后小于m，简单说就是，在前面m不为1的位绝不能为1，而我们令当前这一位1为0了，对于后面所有位都为1，也不可能大于当前这一位，那么我们就可以根据这进行枚举计算了。这题一看数据范围很大，重量和价值都是1e8级别的，当时还在想是不是背包，原来就是位运算。
2022牛客寒假算法基础集训营2补题
qq_51539561的博客
01-28 182
2022牛客寒假算法基础集训营2 F、小沙的算数（二进制，快速幂） 当时错误思路：先计算某个数的除最高位的1外1的个数，然后用组合来找规律。。。。 正确思路：计算出m二进制形式的1的所有个数，在n个位置上放置时。先找最高位的1能放n个位置上。再找次高位的1能放的位置，因为1与1在m的二进制形式中的位置不同，所有放的位置相互独立，所以次高位也有n种放法。。。最后发现结果为n^cnt种方法。 做题目时，顾全大局，不能死扣一个点，有时退一步再思考会发现海阔天空！ 还有一个点，在快速幂计算时，需要注意n的范围为1
2022牛客寒假算法基础集训营
qq_51776588的博客
01-27 1160
2022牛客寒假算法基础集训营1 L-牛牛学走路 签到题，按照题目意思，遍历字符串，计算最远距离即可。 #include<bits/stdc++.h> using namespace std; int main(){ int t; cin>>t; while(t--){ int l; cin>>l; char ch; double x=0,y=0; double mmax=0; for(
2022牛客寒假算法基础集训营1 ABCDEFGHIJKL
HeartFireY的博客
01-25 508
A.九小时九个人九扇门 思路 首先观察数根的性质，令R(x)R(x)R(x)表示数字xxx的数字根，那么有R(a)+R(b)=R(a+b)R(a) + R(b) = R(a + b)R(a)+R(b)=R(a+b)，根据这个性质： 设dp[i][j]dp[i][j]dp[i][j]表示前iii个人可以组合出jjj的方案数 第iii个人被加入方案时：第i−1i-1i−1个人组合出jjj的状态下可以向第iii个人组合出j+R(a[i])j + R(a[i])j+R(a[i])的状态转移，也就是dp[i]
2023牛客寒假算法基础集训营5题解 4/12
Hey1_的博客
02-01 387
2023牛客寒假算法基础集训营5题解 < 已写：A 、B 、H 、 K >
2021牛客寒假算法基础集训营5 - D石子游戏
weixin_45509601的博客
02-22 1396
前言：哎，这场打的就很nanshou，开局a出俩题，剩下的数学题兴趣就直接无了，结果俩小时直接结束战斗。 结束之后看了一下题解，感觉D题讲的有点麻烦，这边讲一下一种更低效率不过更加直观的做法。如果有看不懂题解的朋友可以尝试一下我的理解。 正文开始# 没看过题目的可以去牛客先看一下。我这里自己出一组数据。 1 5 2 3 3 2 0 2 这里介绍一个算法，差分算法，至于为什么想到的，只能说看到这题就本能的就想到这个算法。 我们对数据进行差分（就是前一个数减后一个数）。得到差分数组cut。 0 1 2 -2 然
2022牛客寒假算法基础集训营3
m0_58178876的博客
01-30 1350
当天去走亲戚了，后来自己vp了一下，只能说逃过一劫，这场真阴间（呜呜呜，被智乃哥哥杀爆了），赛中6赛后8，估算rank在450名左右，打了估计掉分 A：签中签，0 B：背包，6（1） C：dp（补） D：签到，2 E：模拟，175（6） G：数据结构（补） I：尺取，107（5） L：stl+模拟，30 B：智乃买瓜 这题本质就是一个分组背包，每种物品三个操作：选，不选，选一半，其实就是一组里面三个物品，0，整个，半个。至于我为什么wa1，哈哈，忘了取模，棹，前两场每场都因为这个wa过.
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1149
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 758
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 254
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1320
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 728
排序是将多个数据，依指定的顺序进行排列的过程。
【算法】---归并排序（递归非递归实现）
最新发布
何春秋的博客
10-03 1084
归并排序 in Java
牛客暑期多校集训营五题详解：最小行走距离与传送门策略
2020牛客暑期多校集训营第五场的编程题目是关于带权图的路径规划与优化问题，主要涉及C++编程。题目背景是有一个包含n个节点和m条边的图，初始位置在1号节点，需要按照顺序完成k个任务，每个任务包括从一个特定的a[i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值