2024牛客暑期多校训练营第六场

已于 2024-08-02 23:43:34 修改
阅读量175 收藏 4
点赞数 10
文章标签： 算法 深度优先 图论 c++ 数据结构
于 2024-08-01 20:36:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79471581/article/details/140855551
版权

赛时解决题目：A，B，H

目录

赛时解决题目：A，B，H

H:

        题意：

        解题思路：

B:

        题意：

        解题思路：

A:

        题意：

        解题思路：

H:

        题意：抽卡游戏，签到题

        解题思路：记录10连出四星以上，90连出保底，还有大保底判一下就行。

                

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define int long long
#define double long double
#define Int __int128
#define pb push_back
#define MAX_LOG 21
#define ff first
#define ss second
#define M 5005
#define ull unsigned long long
using namespace std;
const double PI=3.1415926535897932385;
const ll LLMAX=9223372036854775807ll;
const ll LLMIN=-9223372036854775808ll;
//const int MAX_INT=0x3f3f3f3f;
const int IIMAX=2147483647;
const int IIMIN=-2147483648;
const int INF=0x3f3f3f3f;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b)
{
    if(b) while((a%=b)&&(b%=a));
    return a+b;
}//最大公约数函数
ll spid(ll a,ll b,ll p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        b>>=1;
        a=a*a%p;
    }
    return ans;
}//快速幂函数
///泡沫在阳光下闪烁，像星辰在寂静得夜空中闪耀

///秋雨
const ll N=2e5+10;
void solve()
{
    string s;cin>>s;
    ll a[6]={0};
    ll cnt90=0,cnt10=0;
    bool ret=0;
    ll ans=1;
    for(auto i:s)
    {
        cnt90++;
        cnt10++;
        if(i=='4'||i=='5'||i=='U')cnt10=0;
        if(i=='5')
        {
            if(ret==1)
            {
                ans=0;break;
            }else
                ret=1,cnt90=0;
        }
        if(i=='U')
        {
            cnt90=0;
            ret=0;
        }
        if(cnt90==90||cnt10==10)ans=0;
    }
    if(ans)
        cout<<"valid\n";
    else cout<<"invalid\n";
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)
    {
        solve();
    }
}
///在秋天邂逅， 在春天发芽，在夏天壮大，在秋天萧瑟，在冬天萎缩，

///而后，春天再度归来。

B:

        题意：奶奶买了一个大蛋糕。蛋糕的形状是正多边形。也就是说，一个所有内角相等且所有边相等的凸多边形。奶奶想把蛋糕切成一个漂亮的图案，和她的朋友们分享。她以逆时针的顺序将顶点0到n - 1编成索引，然后选择一个整数k。之后，她将蛋糕切割成n条直线，将顶点i和顶点(i+k)连接起来，每个i mod n。请帮她算一下。（有道翻译）

        解题思路：模拟一下发现就是正多边形，然后按照规律割线，注意一下会发现k肯定具有对称性，因此可以让k小于n的一半，又发现如果穿过中心点，是一种特殊情况，且只会出现在偶数正多边形，进行特判，最后手动模拟一下，k为2~n/2，会发现k每次加一，画出来的图就会多n块，结论就出来了。

        

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define int long long
#define double long double
#define Int __int128
#define pb push_back
#define MAX_LOG 21
#define ff first
#define ss second
#define M 5005
#define ull unsigned long long
using namespace std;
const double PI=3.1415926535897932385;
const ll LLMAX=9223372036854775807ll;
const ll LLMIN=-9223372036854775808ll;
//const int MAX_INT=0x3f3f3f3f;
const int IIMAX=2147483647;
const int IIMIN=-2147483648;
const int INF=0x3f3f3f3f;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b)
{
    if(b) while((a%=b)&&(b%=a));
    return a+b;
}//最大公约数函数
ll spid(ll a,ll b,ll p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        b>>=1;
        a=a*a%p;
    }
    return ans;
}//快速幂函数
///泡沫在阳光下闪烁，像星辰在寂静得夜空中闪耀

///秋雨
const ll N=2e5+10;
void solve()
{
    ll n;cin>>n;
    ll k;cin>>k;
    if(k>n/2)
    {
        k=n-k;
    }
    if(n%2==0&&k==n/2)
    {
        cout<<n<<'\n';
    }else
    {
        ll ans=n+1;
        ans+=(k-1)*n;
        cout<<ans<<'\n';
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t=1;

    while(t--)
    {
        solve();
    }
}
///在秋天邂逅， 在春天发芽，在夏天壮大，在秋天萧瑟，在冬天萎缩，

///而后，春天再度归来。


A:

        题意：（我也没想过这题目信息量挺大），有A人和B人两个人分蛋糕，然后他们有个分蛋糕的方式，首先给一棵现成的树，根节点为1，给你n个点，和n-1条边，边权值要么是1要么是0。两个人轮流走，A先走，从根节点开始，选取当前点的子节点中的一个，捡起边权值1或0，直到走到终点。这样把路径上的1，0拼起来成了一个01字符串，长度假设为m。那么这时B人要把蛋糕任意切成m份（也可以是空的几份），然后两个人按照01字符串的规则，如果是数字1，那么A人从分出来的蛋糕中挑一块，如果是0则B去挑一块。问A人最多能吃蛋糕几分之几。

        解题思路：A肯定希望早拿和多拿1，B也是，那么dfs跑一下就行，对于每个01串，ans只需要取个min即可，因为蛋糕是由B去切成块的，而他们肯定都先拿大的，所以B肯定切出来是均等的有效块数。那么对于每轮进行贪心，A想要ans大，B想要ans小，递归即可。

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define int long long
#define double long double
#define Int __int128
#define pb push_back
#define eb emplace_back
#define MAX_LOG 21
#define ff first
#define ss second
#define M 5005
#define ull unsigned long long
using namespace std;
const double PI=3.1415926535897932385;
const ll LLMAX=9223372036854775807ll;
const ll LLMIN=-9223372036854775808ll;
//const int MAX_INT=0x3f3f3f3f;
const int IIMAX=2147483647;
const int IIMIN=-2147483648;
const int INF=0x3f3f3f3f;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b)
{
    if(b) while((a%=b)&&(b%=a));
    return a+b;
}//最大公约数函数
ll spid(ll a,ll b,ll p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        b>>=1;
        a=a*a%p;
    }
    return ans;
}//快速幂函数
///泡沫在阳光下闪烁，像星辰在寂静得夜空中闪耀

///秋雨
const ll N=2e5+10;
ll a[N];
vector<ll>go[N];
map<PLL,ll>mp;
double dfs(ll u,ll fa,ll ret,double cnt0,double cnt1,double ans)
{
    if(cnt0+cnt1>=1)ans=min(ans,cnt1/(cnt0+cnt1));
    double res=ans;
    if(go[u].empty())
    {
        return res;
    }
    bool ru=0;
    for(auto i:go[u])
    {
        if(i==fa)continue;
        if(!ru)
        {
            if(ret)ans=dfs(i,u,ret^1,cnt0+(mp[{min(u,i),max(i,u)}]==0),cnt1+(mp[{min(u,i),max(i,u)}]==1),res);
            else ans=dfs(i,u,ret^1,cnt0+(mp[{min(u,i),max(i,u)}]==0),cnt1+(mp[{min(u,i),max(i,u)}]==1),res);
            ru=1;
            continue;
        }
        if(ret)ans=max(dfs(i,u,ret^1,cnt0+(mp[{min(u,i),max(i,u)}]==0),cnt1+(mp[{min(u,i),max(i,u)}]==1),res),ans);
        else ans=min(dfs(i,u,ret^1,cnt0+(mp[{min(u,i),max(i,u)}]==0),cnt1+(mp[{min(u,i),max(i,u)}]==1),res),ans);
    }
    res=ans;
    return res;
}
void solve()
{
    ll n;
    cin>>n;
    for(int i=1; i<=n; i++)a[i]=0,go[i].clear();
    for(int i=1; i<n; i++)
    {
        ll u,v,w;
        cin>>u>>v>>w;
        if(u>v)swap(u,v);
        go[u].eb(v);
        go[v].pb(u);
        mp[{u,v}]=w;
    }
    cout<<fixed<<setprecision(13)<<dfs(1,-1,1,0,0,1)<<'\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)
    {
        solve();
    }
}
///在秋天邂逅， 在春天发芽，在夏天壮大，在秋天萧瑟，在冬天萎缩，

///而后，春天再度归来。

F:图论（构造）

        题意：给一个树林，然后问这树林的补图存不存在哈密尔顿路径。

哈密尔顿路径：经过所有点，且每个点只经过一次。

补图：补图中存在边的两点，在原图中不存在边。

解题思路：会发现点数在2，3时需要特判一下，剩下的必然树的直径是大于4的，那么可以根据深度进行分层，会发现奇数层和偶数层可以几乎任意的去接，而同一层的点也可以随意接在一起（因为题目保证没有环）。这时候就需要判断一下只有一圈的菊花图，因为连完树枝后，没有点可以连到中点，但因为题目是树林，所以可以把这个点接到下一棵树的脑袋上。

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define int long long
#define double long double
#define Int __int128
#define pb push_back
#define eb emplace_back
#define N (int)3e5+10
#define MAX_LOG 21
#define ff first
#define ss second
#define M 5005
#define ull unsigned long long
using namespace std;
const double PI=3.1415926535897932385;
const ll LLMAX=9223372036854775807ll;
const ll LLMIN=-9223372036854775808ll;
//const int MAX_INT=0x3f3f3f3f;
const int IIMAX=2147483647;
const int IIMIN=-2147483648;
const int INF=0x3f3f3f3f;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b)
{
    if(b) while((a%=b)&&(b%=a));
    return a+b;
}//最大公约数函数
ll spid(ll a,ll b,ll p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        b>>=1;
        a=a*a%p;
    }
    return ans;
}//快速幂函数
///泡沫在阳光下闪烁，像星辰在寂静得夜空中闪耀

///秋雨

void solve()
{
    int n,m;
    cin>>n>>m;
    vector<vector<int>>G(n+1);
    for(int i=0;i<m;i++)
    {
        int x,y;
        cin>>x>>y;
        G[x].eb(y);
        G[y].eb(x);
    }
    if(n==2)
    {
        if(m==0)
            cout<<"1 2\n";  /// 补图是唯一的哈密尔顿路径
        else
            cout<<"-1\n";
    }
    else if(n==3)
    {
        if(m==0)
            cout<<"1 2 3\n";
        else if(m==2)
        {
            cout<<"-1\n";
        }
        else if(m==1)
        {
            if(G[1].size()&&G[3].size())
            {
                cout<<"1 2 3\n";
            }
            else if(G[1].size()&&G[2].size())
            {
                cout<<"1 3 2\n";
            }
            else if(G[2].size()&&G[3].size())
            {
                cout<<"2 1 3\n";
            }
        }
    }
    else      // n>=4
    {
        vector<int>vis(n+1),dist(n + 1);
        int mxidx=0;
        auto dfs=[&](auto self,int u,int fa)->void
        {
            if(dist[u]>dist[mxidx])mxidx=u;
            vis[u]=true;
            for(auto it:G[u])
            {
                if(it==fa)
                    continue;
                else
                {
                    dist[it]=dist[u]+1LL;
                    self(self,it,u);
                }
            }
        };
        vector<PLL>v;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i])
            {
                mxidx=i;
                dfs(dfs,i,0ll);
                dist[mxidx]=0ll;
                int u=mxidx;
                dfs(dfs,mxidx,0ll);
                v.push_back({u,mxidx});
            }
        }
        auto add=[&](int u,int v)->void
        {
            G[u].eb(v);
            G[v].eb(u);
        };
        for (int i=1;i<v.size();i++)
        {
            add(v[i-1].ss,v[i].ff);
        }
        dist[v[0].ff] = 0;
        mxidx=v[0].ff;
        dfs(dfs,mxidx,0);
        int I=dist[mxidx]+1LL;
        if (I<=3)
        {
            cout<<"-1\n";
        }
        else
        {
            vector<vector<int>>VE(dist[mxidx]+2LL);
            for(int i=1;i<=n;i++)VE[dist[i]+1LL].eb(i);
            for (int i=I-1;i>=1;i-=2)
            {
                for (auto x:VE[i])cout<<x<< " ";
            }
            for (int i=I;i>=1;i-=2)
            {
                for (auto x:VE[i])cout<<x<<" ";
            }
            cout<<"\n";
        }
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)
    {
        solve();
    }
}
///在秋天邂逅， 在春天发芽，在夏天壮大，在秋天萧瑟，在冬天萎缩，

///而后，春天再度归来。

暮雨湦箫
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024牛客暑期多校训练营1
2301_80085990的博客
07-17 468
2024牛客暑期多校集训营1 A. A Bit Common C. Sum of Suffix Sums H. World Finals
2024牛客暑期多校训练营3
zjdysq的博客
07-25 605
用优先队列维护不同数字牌的出现次数，每次都取出现次数最多的两个数字相同的牌，按照牌与牌之间数字不同的规则依次放下两个牌，直到优先队列中没有牌或者只有一种牌为止。把牌分成左右数字不同的和左右数字相同的两部分，由于牌可以进行翻转，所以对于左右数字不同的部分，使它左边的数字小于右边的数字，再对这些牌以左边数字为第一关键词，以右边数字为第二关键词进行升序排序。小场后的下一场的开始位置和甲队和乙队的获胜场次，最后通过倍增从后往前遍历，直到遇到某个位置，该位置结束后整体比赛结束再停止，时间复杂度。详细证明见官方题解。
2024牛客暑期多校训练营第四场
2301_79471581的博客
07-25 826
G：题意：给马和将军的坐标，然后马需要喝水，在x轴和y轴有河流，问马喝完水回来的最短路径。题解：挺明显，数学中的镜像对称一下就可以了，让马或将军的坐标对x轴和y轴算出对称点再计算距离取min得到答案。I：题意：给一堆朋友，问有多少个区间，彼此与彼此之间都是朋友。题解：通过题目我们可以知道，你是我朋友，那我一定是你朋友（废话）。那么对于一个新加入的人来说，他必须是我们共同的朋友。
2024暑假牛客多校训练营第二场题解（细述I，H）
2301_79801805的博客
07-19 439
没错，就是前缀和，我们先全部都取，然后看看从0，0取到第i个操作走到哪了，再看看这个点离x，y还差了多少，看看前面走过的部分有没有这些差值，我们把这些差值去掉不就相当于到了x，y？因此我们每次走过一个操作，就储存这次操作后的坐标，让那个坐标对应的值加1，然后再去找对当前坐标来说，和x，y差了多少，看看之前有没有走到过这样的差值坐标，走到过几次，把那部分去掉就是我们到x，y需要的子串，然后对于后面的随便取都是答案，贡献就是差值坐标的数量*i后面的串的长度（包括i本身别忘了）。
2023牛客暑假多校训练营2
m0_74087709的博客
07-22 269
所以要保证y^2大于等于x*10^i,如果y^2小于x*10^i的话,x不可能是y^2的前缀的。
2024牛客暑假多校训练营2——两道入门DP（C题，I题）选讲
华鑫的专栏
07-18 577
你合入的代码越多，可能会带入的bug也就越多，带入的bug越多，你要解bug合入的代码也就越多。做成事儿的道、法、术～1、首先，做一件事儿时，要去灵魂拷问自己，为什么要做，发心不对，动作变形，没法。终于明白了递归和动态规划的区别，不愧是群众严选，把通过率50以上的题都做完了，继续加油，简单题信心很。#软件开发笔面经#6.1北京时间上午10点一面简单自我介绍，项目介绍----------------方法：递归+回溯 n对括号的生成就是n个左括号和n个右括号组成的合法排列，在使用了一个。
2020牛客暑期多校训练营（第五场）
Irving0323的博客
08-05 192
多校
2019牛客暑期多校训练营（第二场）
cheng__yu_的博客
05-25 166
题目A Eddy Walker （概率思维）B Eddy Walker 2 （线性递推）D Kth Minimum Clique （bitset 维护团）E MAZE （线段树上维护矩阵中DP值的转移）F Partition problem （dfs + 优化）H Second Large Rectangle （单调栈）J Subarray （思维 + 抓住小范围） 链接：https://ac.nowcoder.com/acm/contest/882 A Eddy Walker （概率思维） 题意： n 个
2022牛客暑期多校训练营2(总结+补题)
m0_51028279的博客
07-25 647
这把牛客是我们目前来说打的最好的一把，开局我和队友一签到，一开始看GGG没什么思路，队友一打了个表后我发现了按根号分布的规律，遂跑去写，一发直接过（这题由于其他队伍开局莽，大都wa了1～3发），罚时领先，由于不会第二道签到题KKK整个队直接进入了罚坐阶段，我看到DDD过了三十多队，还是个图论，遂直接放弃第二道签到，直接莽图论题，而另外两个队友对KKK也没想法，他们就去做HHH，过了将近三个小时，我DDD直接一发过，队友也在2min2min2min后过了HHHJJJ。...
2024牛客暑期训练营第一场
07-22
### 2024牛客暑期训练营第一场补题报告关键知识点解析 #### 题目C: Accept **核心思想**: 维护序列总和及其权值变化。 **详细解析**: - **背景**: 给定一个序列 `a[1], a[2], ..., a[n]` 和一系列操作，每轮操作...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
[知识点]-[最短路]
m0_52398496的博客
07-31 462
【代码】[知识点]-[最短路]
C++初学者指南-5.标准库(第二部分)--更改元素算法
最新发布
silencestarsky的博客
08-03 482
本文介绍了C++标准库中的元素更改算法，包括如何使用fill、generate、transform等函数来填充、生成和替换元素。这些算法有助于简单且高效地处理容器中的数据，同时提供了示例代码以辅助学习。
「数组」Knuth洗牌算法|C++random库简单介绍 / LeetCode 384（C++）
dakingffo的博客
08-03 229
Knuth算法可以公平地对数组进行随机排序。
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 77
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值