“蔚来杯“2022牛客暑期多校训练营2补题记录(DGHJKL)

已于 2022-07-27 19:43:22 修改
阅读量544 收藏
点赞数 3
分类专栏： 牛客多校 文章标签： 算法 c++ 开发语言
于 2022-07-27 19:42:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49593247/article/details/126020692
版权

把题补了,感觉要自己梳理一下,就写一下题解,

后续会把其他自己能补的也补了.

"蔚来杯"2022牛客暑期多校训练营2_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJ牛客ACM提高训练营是面向ICPC/CCPC/CSP/NOI比赛备战的选手，由金牌选手命题，提高训练高难度的编程比赛，ACM/NOI拔高训练营。https://ac.nowcoder.com/acm/contest/33187

目录

D.Link with Game Glitch(SPFA判断负环,小数转log存储)

G.Link with Monotonic Subsequence(构造,签到)

H.Take the Elevator(模拟,贪心)

J.Link with Arithmetic Progression(数学,线性回归方程)

K.Link with Bracket Sequence I(括号匹配,dp)

L.Link with Level Editor I

D.Link with Game Glitch(SPFA判断负环,小数转log存储)

思路:我们现在a个b物品转化为c个d物品,可以看成一个b物品可以转化为(c/a)个d物品,题目问c缩小几分之几可以保证不会无限的增长下去.首先明了,如果可以无限生成的话就肯定是形成了一个循环,而且这个循环是成倍增长的,也就是说这个环的增长倍数(c/a)是>1的,这样的话就会无限的增长.此时我们就可以把这个问题抽象成一个图论问题.:

我们按照题目给的生成关系建立单向边,边权就是每一组的(c/a).当然,如果连续处理多个这种小数相乘的话很容易丢精,那么就可以尝试把边建立为log,就w=log(c/a).这样的话边权就不是一个小时,而是一个带小数点的负数,不那么容易丢精.

然后我们对着这个图用spfa跑最长路(因为本来按照题意路径就在增长(c/a大于1的话)).然后用spfa判断负环.这里判断负环是根据spfa的性质,如果边权(也就是c/a)>1的话那么spfa的"缩点操作"就会无限伸长.那么这里就可以判断次数即可判断负环.而对于题目所说的要更改的w,(按照题意就是让每个边变为c/a*k,k为我们所求的倍数答案,范围是[0,1]).那么根据之前的log保证精度的写法,这个式子就变成了log(c/a)+log(k).这个k的取值对结果产生单调性,那么我们就可以采用二分k的大小,然后用SPFA判断负环进行check即可求出答案.

ps:这里向严格鸽学了个小数二分的方法,不用l<r.直接进行100次二分

for(int i=0;i<=100;i++)
    {
        double mid=(l+r)/2;
        if(check(mid))
            l=mid;
        else
            r=mid;
    }

一定可以保证精度了.

AC code:

#include<bits/stdc++.h>
using namespace std;
int tot=0,n;
struct node
{
    int to,ne;
    double val;
}edge[2010];
int h[1010];
void add(int x,int y,double val)
{
    edge[++tot].to=y;
    edge[tot].ne=h[x];
    edge[tot].val=val;
    h[x]=tot;
    return ;    
}
int vis[1010],cnt[1010];
double dis[1010];
int check(double mid)
{
    mid=log(mid);
    queue<int>qu;
    for(int i=1;i<=n;i++)
    {
        cnt[i]=vis[i]=0;
        dis[i]=0.0;
        qu.push(i);
    }
    while(qu.size())
    {
        int st=qu.front();
        qu.pop();
        vis[st]=0;
        for(int i=h[st];i!=-1;i=edge[i].ne)
        {
            double len=edge[i].val;
            int en=edge[i].to;
            if(dis[st]+mid+len>dis[en])
            {
                dis[en]=dis[st]+mid+len;
                cnt[en]=cnt[st]+1;
                if(cnt[en]>n)
                    return 0;
                if(vis[en]==0)
                {
                    vis[en]=1;
                    qu.push(en);
                }
            }
        }
    }
    return 1;
}
void solve()
{
    memset(h,-1,sizeof h);
    int m,u,v;
    double c1,c2;
    cin>>n>>m;
    while(m--)
    {
        cin>>c1>>u>>c2>>v;
        add(u,v,log(c2/c1));
    }              
    double l=0.0,r=1.0;
    for(int i=0;i<=100;i++)
    {
        double mid=(l+r)/2;
        if(check(mid))
            l=mid;
        else
            r=mid;
    }
    cout<<fixed<<setprecision(10)<<l<<endl;
    return ;
}
signed main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    solve();
    return 0;
}

G.Link with Monotonic Subsequence(构造,签到)

思路:把数组分块,每一块内保证递增,然后每一开之间保证递减即可.当两者分块接近于\sqrt{n}的时候对于结果的贡献就会更小.比如(1-9),我们分成三块1,2,3   4,5,6    7,8,9,然后把这三块倒序排列:

7,8,9,4,5,6,1,2,3.此时答案最小.

AC code:

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int l,r;
};
vector<node>ve;
void solve()
{
    ve.clear();
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        int k=n/i+(n%i!=0);
        if(i<k)
            continue;
        for(int j=1;j<=n;j+=k)
            ve.push_back({j,min(n,j+k-1)});
        for(int j=ve.size()-1;j>=0;j--)
        {
            for(int k=ve[j].l;k<=ve[j].r;k++)
            {
                cout<<k<<" ";
            }
        }
        cout<<endl;
        break;
    }
    return ;
}
signed main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    int t;
    cin>>t;
    while(t--)
       solve();
 
    return 0;
}

H.Take the Elevator(模拟,贪心)

思路:n个人,一个电梯,电梯最多容纳m个人,楼高k.

我们可以把每个人上楼下楼的操作分成两类,然后都看成下楼的操作.然后进行模拟,从最高处向下走.当遇到一个区间的上端点,(把那个上下楼操作看成一个区间)就说明此时需要上来一个人.下端点就看成电梯上要下一个人.我们就记上人为+1,下人为-1.每个点就会存在一个值,再把这些值按照序号进行排序.从最高处往下遍历.当同一个点有上下人多个操作时,先下人在上人.

当到某个点时,电梯上的人超过了上限,那么就需要在这个高度的点在开一个电梯.那么我们把对于上升下降处理的两种情况.因为我们每次坐电梯都有上升下降两种操作,那么每次我们之前储存的上升下降的电梯楼层进行两两匹配,然后每次取能到的最高点,计算要经过的层数即可.

#include<bits/stdc++.h>
#define int long long
using namespace std;
struct node
{
    int id,val;
};
bool cmp(node a,node b)
{
    if(a.id!=b.id)
        return a.id>b.id;
    else
        return a.val<b.val;
}
vector<node>up,down;
vector<int>ans_up,ans_down;
void solve()
{
    int x,y,n,m,k;
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
    {
        cin>>x>>y;
        if(x<y)
        {
            up.push_back({x,-1});
            up.push_back({y,1});
        }
        else if(x>y)
        {
            down.push_back({x,1});
            down.push_back({y,-1});
        }
    }
    sort(up.begin(),up.end(),cmp);
    sort(down.begin(),down.end(),cmp);

    int cnt=0;
    for(int i=0;i<up.size();i++)
    {
        cnt+=up[i].val;
        if(cnt>ans_up.size()*m)
            ans_up.push_back(up[i].id);
    }
    cnt=0;
    for(int i=0;i<down.size();i++)
    {
        cnt+=down[i].val;
        if(cnt>ans_down.size()*m)
            ans_down.push_back(down[i].id);
    }

    int maxx=max(ans_up.size(),ans_down.size());
    while(ans_up.size()<maxx)
        ans_up.push_back(0);
    while(ans_down.size()<maxx)
        ans_down.push_back(0);
    int ans=0;
    for(int i=0;i<maxx;i++)
    {
        ans+=2*(max(ans_up[i],ans_down[i])-1);
    }
    cout<<ans<<endl;
    return ;
}
signed main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    solve();
    return 0;
}

J.Link with Arithmetic Progression(数学,线性回归方程)

直接高中考点.

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N =5e5+10,mod=998244353;
int read() 
{
    int x=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
    return x*f;
}
int arr[100005];
void solve()
{
    int n;
    double ans=0,xy=0.0,x2=0.0;
    n=read();
    double avgx=0.0,avgy=0.0;
    for(int i=1;i<=n;i++)
    {
        arr[i]=read();
        avgx=avgx+i;
        avgy=avgy+arr[i];
    }
    avgx/=n;
    avgy/=n;
    for(int i=1;i<=n;i++)
    {
        double ax=i-avgx,ay=arr[i]-avgy;
        xy=xy+ax*ay;
        x2=x2+ax*ax;
    }
    double k=xy/x2;
    double b=avgy-k*avgx;
    for(int i=1;i<=n;i++)
    {
        ans+=(i*k+b-arr[i])*(i*k+b-arr[i]);
    }
    printf("%.8lf\n",ans);
    return ;
}
signed main()
{
    int t;
    t=read();
    while(t--)
        solve();
    return 0;
}

K.Link with Bracket Sequence I(括号匹配,dp)

思路:f(i,j,k)的含义是原串长度为j,和子串相匹配的长度为i,此时原串左括号比右括号多k的方案的总数.

详细思路在注释里:

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N =5e5+10,mod=1e9+7;
int f[210][210][210];
/*
三维状态,第三维表示此时左括号比右括号多k个
状态转移方程是:
当当前的字符串遍历到s[j]=='('时
f[i][j][k]由下面两个状态转移过来
(1)f[i-1][j-1][k-1] 和原串匹配成功,j比原来+1,当前原串此处为'(',但是原串之前要比
此时的原串少一个'(',所以原来k的要小1
(2)f[i-1][j][k+1]   和原串匹配失败,j不变,原串此时是')',同理,之前比现在多一个'(',
所以k要大1
同理
当当前的字符串遍历到s[j]==')'时
f[i][j][k]由下面两个状态转移过来
(1)f[i-1][j][k-1] 和原串匹配失败,j不变,但是此时原串是'(',但是上一层比原串少一个'('
,所以原来k的要小1
(2)f[i-1][j-1][k+1]   和原串匹配失败,原串此时是')',上一层比这一层多一个')',
所以k要大1
当当前的字符串遍历到s[j]==')'时
*/
void solve()
{
    string s;
    int n,m;
    cin>>n>>m;
    for(int i=0;i<=m+1;i++)
        for(int j=0;j<=m+1;j++)
            for(int k=0;k<=m+1;k++)
                f[i][j][k]=0;
    cin>>s;
    s=" "+s;
    f[0][0][0]=1;
    for(int i=1;i<=m;i++)
    {
        for(int j=0;j<=n;j++)
        {
            for(int k=0;k<=i;k++)
            {
//注意边界处理!
                if(j==0)
                {   
                    if(k)
                        f[i][j][k]=(f[i][j][k]+f[i-1][j][k-1])%mod;
                    f[i][j][k]=(f[i][j][k]+f[i-1][j][k+1])%mod;
                }
                else
                {   
                    if(s[j]=='(')
                    {    
                        if(k)
                            f[i][j][k]=(f[i][j][k]+f[i-1][j-1][k-1]+f[i-1][j][k+1])%mod;
                        else
                            f[i][j][k]=(f[i][j][k]+f[i-1][j][k+1])%mod;
                    }
                    else
                    {
                        if(k)
                            f[i][j][k]=(f[i][j][k]+f[i-1][j][k-1]+f[i-1][j-1][k+1])%mod;
                        else
                            f[i][j][k]=(f[i][j][k]+f[i-1][j-1][k+1])%mod;                    
                    }
                    
                }
            }
        }
    }
    cout<<f[m][n][0]<<endl;
    return ;
}
signed main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    int t;
    cin>>t;
    while(t--)
       solve();
    return 0;
}

L.Link with Level Editor I

思路:用dp写,详细思路见代码(有点抽象):

#include <bits/stdc++.h>
using namespace std;
signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<int> f(m + 1), p(m + 1);
    //p为上一层的情况,也就是上一层到达下标的位置的最近世界编号
    //f用于转移上一层的情况,(且保证只走一步或者不走,所以还要把f的值赋给p)
    int ans =  0x3f3f3f3f;
    for (int i = 1; i <= n; i++) {
        p[1] = i;
        //如果在第i个世界从1出发
        int k;
        cin >> k;
        for (int j = 1; j <= k; j++) {
            int x, y;
            cin >> x >> y;
            f[y] = max(f[y], p[x]);
//保持不动或者走一步
            if (f[m])ans = min(ans, i - f[m] + 1);     
//f保存的就是从某个世界的1号节点能到达当前节点,存的就是这个出发世界的编号
//所以当f的值存在时,就直接相减求出
        }
        p=f;
        //到达下一层,f作为从p更新而来的下一层,到达下一层循环时就作为了新的上一层
    }
    if (ans >= 0x3f3f3f3f)
        cout << -1 << endl;
    else
        cout << ans << endl;

    return (0 ^ 0);
}

ccsu_yuyuzi
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
“蔚来杯“2022牛客暑期多校训练营2 DGHJKL题解
Shanhj的博客
08-10 226
DGHJKL题解
“蔚来杯“2022牛客暑期多校训练营2 个人题解集合
HeartFireY的博客
07-24 700
显然要生成无限物品，需要存在一个环且沿该环生成一轮得到的物品数目比原来更多，即为环上满足所有的边有。显然可以二分答案来做。那么可以分上下两个过程，分别存下所有的端点(带标记)，每个乘客分配的轮数可以通过。首先枚举插入的括号数量，原来的括号序列和左括号比右括号多的数量。，即左括号的数量大于右括号的数量，并且使用的原括号的数量。的括号序列(不保证合法性)，求在此基础上生成的长度为。如果目前枚举到的括号为左括号，并且使用的原括号的数量。如果此时枚举到的是一个右括号，并且。、使用的原来的序列中的括号数量为。...
“蔚来杯“2022牛客暑期多校训练营3 补题题解（A、C、J）
qiaodxs的博客
07-27 296
赛后补的，不得不说这个题给的挺绕的，给定某个到达i点的四个点，刚开始一直在迷惑到底什么意思，理解题意理解了半天，不过好在最后理解了。依旧是队友的牛逼思路，对任意两个字符串排序，如果ab...
“蔚来杯“2022牛客暑期多校训练营2
qq_34832548的博客
07-26 398
这里我们采取的方式是组内升序，组间降序，那么我们把它分成sqrt(n)个组，每个组内有sqrt(n)个数，那么答案就是。最长上升子序列长度和最长下降子序列长度的最大值，问你这个的最小值是多少。给你一个数字n，你需要构造一个1-n的排列，排列的价值为。.....................
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
算法-KMP字符串匹配
xx_xb的博客
07-23 166
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 386
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 643
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 737
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 304
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 531
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 748
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 243
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 399
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
牛客暑期多校集训营五题详解：最小行走距离与传送门策略
2020牛客暑期多校集训营第五场的编程题目是关于带权图的路径规划与优化问题，主要涉及C++编程。题目背景是有一个包含n个节点和m条边的图，初始位置在1号节点，需要按照顺序完成k个任务，每个任务包括从一个特定的a[i...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值