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

最新推荐文章于 2023-02-06 21:38:50 发布
最新推荐文章于 2023-02-06 21:38:50 发布
阅读量137 收藏
点赞数
分类专栏： 补题 文章标签： 算法 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/margo004/article/details/128716910
版权

ACDEFGHKLM 题解：

A World Final? World Cup! (I)

模拟即可

#include<bits/stdc++.h>
//#define int long long
using namespace std;
const int N=1e6;
int n,a[N];
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
    cin>>T;
    while(T--)
    {
        string s;
        cin>>s;
        int aa=0,bb=0;
        s=" "+s;
        int ans=1;
        bool ok=false;
        for(int i=1;i<=10;i++)
        {
            if(i%2==1)
            {
                if(s[i]=='1')
                    aa++;
                if(aa>bb+5-ans+1)
                {
                    cout<<i<<"\n";
                    ok=true;
                    break;
                }
                if(aa+5-ans<bb)
                 {
                    cout<<i<<"\n";
                    ok=true;
                    break;
                }                   
            }
            else
            {
                if(s[i]=='1')
                    bb++;
                if(bb>aa+5-ans)
                    {
                        cout<<i<<"\n";
                        ok=true;
                        break;
                    }
                if(bb+5-ans<aa)
                     {
                        cout<<i<<"\n";
                        ok=true;
                        break;
                    }                   
                ans++;
            }
        }
        if(!ok)
            {
                if(aa!=bb)
                    cout<<10<<"\n";
                else 
                    cout<<-1<<"\n";
            }
    }
    return 0;
}

C现在是，学术时间 (I)

直接模拟，或者看出来一人一篇文章即可

#include<bits/stdc++.h>
//#define int long long
using namespace std;
const int N=1e6;
int n,a[N];
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        sort(a+1,a+1+n);
        int ans=0;
        int i=n+1; 
        int sum=n;
        for(int j=1;j<=n;j++)
        {
            if(a[j]!=0)
            {
                i=j;
                sum-=j-1;
                break;
            }
        }
        while(i<=n)
        {
            if(sum-a[i]>=0)
            {
                ans+=a[i];
                sum-=a[i];
                i+=a[i];
            }
            else
            {
                ans+=min(sum,a[i]);
                break;
            }
        }
        cout<<ans<<"\n";
    }
    return 0;
}

D现在是，学术时间 (II)

分类讨论即可，每次选四个顶点作为另一个顶点判断最值

#include<bits/stdc++.h>
using namespace std;
double x,y,xp,yp;
int t;
double iou;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    cin>>t;
    while(t--)
    {
        cin>>x>>y>>xp>>yp;
        if(xp==x&&(yp==0||yp==y))
        {
            iou=1;
        }
        else if(yp==y&&(xp==0||xp==x))
        {
            iou=1;
        }
        else if(xp<=x&&yp<=y)
        {
            iou=max(xp*(y-yp),max(xp*yp,max((x-xp)*yp,(x-xp)*(y-yp))));
            iou/=(x*y);
        }
        else if(xp>x&&yp>y)
        {
                iou=(x*y)/(xp*yp);
        }
        else if(xp>x)
        {
            iou=max((x*(y-yp))/(x*y+(xp-x)*(y-yp)),(x*yp)/(x*y+(xp-x)*yp));
        }
        else if(yp>y)
        {
            iou=max((xp*y)/(x*y+xp*(yp-y)),((x-xp)*y)/(x*y+(x-xp)*(yp-y)));
        }
        else
        {
            iou=(x*y)/(xp*abs(yp-y));
        }
        cout<<fixed<<setprecision(9)<<iou<<"\n";
    }
    return 0;
}

E鸡算几何

题解：（借鉴题解 | #2023牛客寒假算法基础集训营1#_牛客博客 (nowcoder.net)）

首先把初始状态和最终状态的中点（B）平移至原点，然后将其中初始状态和最终状态的同一条边旋转至同一条坐标轴的同一个方向上，我选的（应该）是y轴正方向（由于边长不同，需要把边进行对应，也就是交换初始状态或最终状态的A、C点，体现在vector上就是翻转），最后考虑两种状态下的剩下一个点是否在y轴同侧，是就说明不一定需要操作三，否则必须使用操作三。

#include <bits/stdc++.h>
using namespace std;
using point_t=long double;  
constexpr point_t eps=1e-8;
constexpr long double PI=3.1415926535897932384l;
template<typename T> struct point{
    T x,y;
    bool operator==(const point &a) const {return (abs(x-a.x)<=eps && abs(y-a.y)<=eps);}
    bool operator<(const point &a) const {if (abs(x-a.x)<=eps) return y<a.y-eps; return x<a.x-eps;}
    bool operator>(const point &a) const {return !(*this<a || *this==a);}
    point operator+(const point &a) const {return {x+a.x,y+a.y};}
    point operator-(const point &a) const {return {x-a.x,y-a.y};}
    point operator-() const {return {-x,-y};}
    point operator*(const T k) const {return {k*x,k*y};}
    point operator/(const T k) const {return {x/k,y/k};}
    T operator*(const point &a) const {return x*a.x+y*a.y;}  
    T operator^(const point &a) const {return x*a.y-y*a.x;}  
    int toleft(const point &a) const {const auto t=(*this)^a; return (t>eps)-(t<-eps);} 
    T len2() const {return (*this)*(*this);} 
    T dis2(const point &a) const {return (a-(*this)).len2();}  
    long double len() const {return sqrtl(len2());}  
    long double dis(const point &a) const {return sqrtl(dis2(a));} 
    long double ang(const point &a) const {return acosl(max(-1.0l,min(1.0l,((*this)*a)/(len()*a.len()))));} 
    point rot(const long double rad) const {return {x*cos(rad)-y*sin(rad),x*sin(rad)+y*cos(rad)};} 
    point rot(const long double cosr,const long double sinr) const {return {x*cosr-y*sinr,x*sinr+y*cosr};} 
};
using Point=point<point_t>;
int main(){
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int T = 1;
    cin>>T;
    while(T--){
        vector<Point> s(3),t(3);
        for(auto &[x,y] : s){
            cin>>x>>y;
        }
        for(auto &[x,y] : t){
            cin>>x>>y;
        }
        if(abs(s[1].dis2(s[0]) - s[1].dis2(s[2])) <= eps) goto no;
        if(abs(s[1].dis2(s[0]) - t[1].dis2(t[0])) > eps) reverse(t.begin(), t.end());
        {
            auto [dx,dy] = s[1];
            for(auto &[x,y] : s){
                x -= dx;
                y -= dy;
            }
            auto d = s[1].dis(s[0]);
            auto si = s[0].x/d , co = s[0].y/d;
            for(auto &x : s){
                x = x.rot(co,si);
            }
        }
        {
            auto [dx,dy] = t[1];
            for(auto &[x,y] : t){
                x -= dx;
                y -= dy;
            }
            auto d = t[1].dis(t[0]);
            auto si = t[0].x/d , co = t[0].y/d;
            for(auto &x : t){
                x = x.rot(co,si);
            }
        }
        if(t[2].x*s[2].x<0 || t[2].y*s[2].y<0) goto yes;
        else goto no;
        if(0) yes: cout<<"YES"<<endl;
        if(0) no:  cout<<"NO"<<endl;
    }
    return 0;
}

F鸡玩炸蛋人

由于图不一定联通，那么当有不同联通块里都有ci!=0时，则输出0，最后还剩下ci全为0或者ci!=0的情况在同一个联通块里面，当ci全为0的时候，答案为每个连通块的大小的平方之和，当ci!=0的情况在同一个连通块里面时，答案为这个连通块的大小的平方。

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6;
int n,m,c[N],ss[N];
struct DSU {
    std::vector<int> f, siz;
    DSU(int n) : f(n), siz(n, 1) { std::iota(f.begin(), f.end(), 0); }
    int leader(int x) {
        while (x != f[x]) x = f[x] = f[f[x]];
        return x;
    }
    bool same(int x, int y) { return leader(x) == leader(y); }
    bool merge(int x, int y) {
        x = leader(x);
        y = leader(y);
        if (x == y) return false;
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }
    int size(int x) { return siz[leader(x)]; }
};
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m;
    DSU dsu(n+10);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        cin>>x>>y;
        dsu.merge(x,y);
    }
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        cin>>c[i];
        int fx=dsu.leader(i);
        ss[fx]+=c[i];
        sum+=c[i];
    }
    vector<bool>st(n+10,false);
    if(sum==0)
    {
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            int xx=dsu.leader(i);
            if(!st[xx])ans+=dsu.size(xx)*dsu.size(xx);
            st[xx]=true;
        }
        cout<<ans;
        return 0;
    }
    else
    {
        for(int i=1;i<=n;i++)
        {
            int xx=dsu.leader(i);
            if(ss[xx]==sum)
            {
                cout<<dsu.size(xx)*dsu.size(xx);
                return 0;
            }
        }
        cout<<0;
    }
}

G鸡格线

线段树，观察到每个数经过几次fx之后会变成一个不变值，然后用标记来标记是否是不变值。

//线段树4(结构体线段树，懒标记下传)
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6;
int a[maxn];
int n,m;
struct tree
{
    int l,r;
    long long sum;
    bool lazy;
}t[4*maxn+2];
void bulid(int p,int l,int r)
{
    t[p].l=l;t[p].r=r;
    if(l==r)
    {
        t[p].sum=a[l];
        t[p].lazy=false;
        return;
    }
    int mid=l+r>>1;
    bulid(p*2,l,mid);
    bulid(p*2+1,mid+1,r);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
    t[p].lazy=(t[p*2].lazy&&t[p*2+1].lazy);
}
//区间修改[x,y]
void update(int p,int x,int y,int z,int k){
    if(x<=t[p].l && y>=t[p].r)
    {
        if(t[p].lazy)return ;
        if(t[p].l==t[p].r)
        {
            int summ=t[p].sum;
            for(int i=1;i<=k;i++)
            {
                int next=round(10*sqrt(summ));
                if(next==summ)
                {
                    t[p].lazy=true;
                    break;
                }
                summ=next;
            }
            t[p].sum=summ;
            return ;
        }
    }
    int mid=t[p].l+t[p].r>>1;
    if(x<=mid) update(p*2,x,y,z,k);
    if(y>mid) update(p*2+1,x,y,z,k);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
    t[p].lazy=(t[p*2].lazy&&t[p*2+1].lazy);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    bulid(1,1,n);
    while(m--)
    {
        int op;
        cin>>op;
        if(op==1)
        {
            int ll,rr,kk;
            cin>>ll>>rr>>kk;
            update(1,ll,rr,0,kk);
        }
        else
            cout<<t[1].sum<<"\n";
    }
    return 0;
}

H本题主要考察了DFS

诈骗题，直接算出总的1和2计算min然后用10去直接减

#include<bits/stdc++.h>
//#define int long long
using namespace std;
const int N=1e6;
int n,a[N];
void dfs(int x,int y)
{
    
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n;
        string s;
        vector<int>v[n*n+10];
        for(int i=1;i<=n*n-1;i++)
        {
            cin>>s;
            for(int j=0;j<s.size();j++)
            {
                v[i].push_back(s[j]-'0');
            }
        }
        int aa=0,bb=0;
        for(int i=1;i<=n*n-1;i++)
        {
            for(auto x:v[i])
            {
                if(x==1)
                    aa++;
                if(x==2)
                    bb++;
            }
        }
        if(aa==bb)
        {
            cout<<10<<"\n";
        }
        else if(aa<bb)
        {
            cout<<10-(bb-aa)<<"\n";
        }
        else
        {
            cout<<10+(aa-bb)<<"\n";
        }
        
    }
    return 0;
}

K本题主要考察了dp

直接构造100100......这样的字符串，可以保证坏区间最少，不需要dp

#include<bits/stdc++.h>
//#define int long long
using namespace std;
const int N=1e6;
int n,a[N],m;
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n>>m;
        int cnt=n-m;
        int ans=n-2;
        cnt/=2;
        if(cnt==0)
        {
            cout<<n-2;
            return 0;
        }
        m-=cnt;
        if(m<=0)
            cout<<0;
        else 
            cout<<m-1;
    }
    return 0;
}

L本题主要考察了运气

求期望即可，为32

M本题主要考察了找规律

dp求即可

#include<bits/stdc++.h>
using namespace std;
double n,m;
double f[1000];
 signed main()
{
    scanf("%lf%lf",&n,&m);    
     for(int i=1;i<=n;++i)
        for(int j=m;j;--j)
            for(int k=1;k<=j;++k)
                f[j]=max(f[j],f[j-k]+(1.0*k/(1.0*j)));
    printf("%.8lf",f[int(m)]);

    return 0;

}
margo004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023牛客OI赛前集训营-提高组（第三场）题解
10-14
2023牛客OI赛前集训营-提高组（第三场）题解
2020牛客暑期多校集训营第三场题解.pdf
01-20
题解
2023牛客寒假算法集训营5
Tom的博客
02-06 540
A. 小沙の好客（贪心 + 排序 + 前缀和 + 二分） 题意： 有一家超市，里面有 n 件商品。 有 Q 个问题，每次询问要求挑选最多 k 个价值不大于 x 的商品，问能挑选的价值和最大为多少。 B. 小沙の博弈（贪心 + 字典序） 题意： 小沙和小雅在玩"拿石子游戏"他们两个人都十分聪明，均会选择最优的方法使得自己获胜。桌子上有 n 个石子 ，他们两个人面前均有排成一行的若干个格子，每个格子都可以置放无限多个石子。 小沙和小雅两个人交替进行操作，小沙先手，每次操作可以从桌子上拿走任意正整数个石子
（qqqqc）自用模板
qqqqc16的博客
07-23 320
代码】jianglycodeforces模板。
2023牛客寒假算法基础集训营4 赛时思路+正解
qq_52358098的博客
01-30 885
也许是qdu acmer写的最后一篇寒假训练营题解。
2023牛客寒假算法基础集训营6 B-阿宁的倍数
TrRicky的博客
02-03 322
而在询问查找时，由于v的first一定有序，故我们只需要在v[a[x]]中二分查找到v[a[x]][mid].first==x，此时v[a[x]][mid].second等于是[n+1,n+x]中约数a[x]的个数，而我们要求的是[n+x+1,n+p]中约数a[x]的个数，而从刚刚前缀和思想中我们就可以简单得出，所求为v[a[x]][v.size()-1].second-v[a[x]][mid].second。给出一个长度为n的数组a，下标从1开始，进行q次操作。如果是修改操作，1
【题解】2023牛客寒假算法基础集训营4
qq_52765554的博客
02-01 710
时，的最大价值，然后用maxv+1-当前价值就是最后结果。先预处理zngg到达每个点的时间，然后qcjj按照地标走。没有办法进行O(n^3)，所以我们想办法将其进行优化。问每个物品价值增加多少可以保证出现在01背包中。进制是效率最高的进制，越靠近e进制效率越高。思路是：必不选的最大价值-必选的价值+1。是常量，对r/lnr求导，发现其在。个数(回报)，那么关于成本的式子。进制数，则表示这个数一共需要。tag: 树状数组，树的遍历。tag: 01背包，简单题。(成本)，一共可以表示。为极值点，则直接输出。
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2023牛客寒假算法基础集训营4
m0_61409183的博客
02-04 504
2023牛客寒假算法基础集训营4
2023牛客寒假算法基础集训营3
qq_62977654的博客
01-25 134
2023牛客寒假算法基础集训营3
牛客2023寒假补题
yueazero的博客
01-21 127
思路：当数字出现的次数sum>k时无论怎么分组最多都只能满足k-1，sum
【题解】2023牛客寒假算法基础集训营2
qq_52765554的博客
01-23 1854
贪心的想，总权值最大，可能存在一个点处于v的边界上，再看数据范围，因此我们可以枚举边界（即H），用map存一下分别对应的改变区间，最后，分别枚举不同的H求maxv即可。贪心的想，当一个大的权值点深度越深，则它被求sum的次数就越多，所以我们就往这个方向靠，求出每个点的深度，深度越深，则赋予其越大的权值，最后累加求和即可。我们发现，当前分成k组时，如果某种元素个数k，则该种元素的造成的影响是k-1，累加即可。tag：贪心，dfs，bfs，树形DP。
2023牛客寒假算法基础训练营2题解
柒月栗子的博客
01-23 503
牛客第二场训练赛题解
牛客竞赛算法入门班怎么样
最新发布
01-14
1. 算法基础知识：包括时间复杂度、空间复杂度、递归、排序算法等。 2. 数据结构：包括数组、链表、栈、队列、树、图等。 3. 常用算法：包括贪心算法、动态规划、回溯算法、分治算法等。 4. 算法竞赛技巧：包括如何...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值