2024牛客暑期多校第三场

已于 2024-07-25 00:02:51 修改
阅读量428 收藏 5
点赞数 5
分类专栏： 题解 文章标签： 算法
于 2024-07-25 00:01:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinchu0309/article/details/140675875
版权

目录

A-Bridging the Gap 2

B-Crash Test

D-Dominoes!

E-Malfunctioning Typewriter

H-Rectangle Intersection

J-Rigged Games

L-Sudoku and Minesweeper

A-Bridging the Gap 2

考虑船上至少L个人，每次相当于向左转移（R-L)个人，一共需要（n-l）/(r-l)次向左，需要向右（n-l）/(r-l)-1次，一共需要l*（（n-l）/(r-l)-1）次，计算出每个人能贡献的向左的次数，累加看看是否大于等于需要的总次数，但可能某些人体力过大，记得取min

#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef  long long ll;
const int N = 1e6+10;

int a[N];
void solve(){
    int sum=0;
    int n,l,r;
    cin>>n>>l>>r;
    int res;
    if((n-l)%(r-l)==0){
        res=(n-l)/(r-l);
    }else{
        res=(n-l)/(r-l)+1;
    }
//    cout<<res<<'\n';
//    res=(res-1)*l;
    int ans=(res-1)*l;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    for(int i=1;i<=n;i++){
        a[i]=(a[i]-1)/2;
        sum+=min(a[i],res-1);
    }
    if(sum>=ans)cout<<"Yes"<<'\n';
    else cout<<"No"<<'\n';
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
//    cin>>T;
    while(T--)solve();

    return 0;
}

B-Crash Test

取个gcd即可

#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef  long long ll;
const int N = 1e6+10;


void solve(){
    int n,m;
    cin>>n>>m;
    int g=-1;
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        if(g==-1)g=x;
        else g=__gcd(g,x);
    }
    int ans=m%g;
    ans=min(ans,g-ans);
    cout<<ans;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
//    cin>>T;
    while(T--)solve();

    return 0;
}

D-Dominoes!

如果一个数字出现了超过 n + 2次，一定无解

容易看出来如果左右都不同很容易构造（左右交换即可）

将所有 xi = yi的骨牌按照每个点数的出现次数放在一个堆中，每次选择 出现次数最大（且和上一个放置的不同）的骨牌放在右侧。 如果发现剩下的 xi = yi的骨牌点数都和上一个相同，不妨设该点数为 p， 从 xi ̸= yi的骨牌堆中挑一个 xi , yi ̸= p的骨牌作为间隔。

#include<bits/stdc++.h>

using namespace std;
#define int long long
typedef long long ll;
const int N = 2e5 + 10;

int n, sn = 0;

stack<pair<int, int>> b1;
map<int, int> m,mp;

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int u, v;
        cin >> u >> v;
        if (u == v) {
            m[u]++;

        } else {
            b1.emplace(u, v);
        }
        mp[u]++;
        mp[v]++;
        if(mp[u]>n+1||mp[v]>n+1){
            cout<<"No"<<'\n';
            return;
        }
    }
    cout<<"Yes"<<'\n';
    priority_queue<pair<int, int>> q;
    for (auto [x, y]: m) {
        q.push({y, x});
    }
    while (q.size() >= 2) {
        auto c1 = q.top();
        q.pop();
        auto c2 = q.top();
        q.pop();
        b1.push({c1.second, c2.second});
        sn++;
        if (c1.first > 1)q.push({c1.first - 1, c1.second});
        if (c2.first > 1)q.push({c2.first - 1, c2.second});
    }

    pair<int, int> sa = {0, 0};
    if (!q.empty())sa = q.top();


    int now = -1;
    while (!b1.empty() || (now != sa.second && sa.first)) {
        if (now != sa.second && sa.first) {
            cout<<sa.second<<" "<<sa.second<<'\n';
            sa.first--;
            now = sa.second;
        }else{
            pair<int, int> cur = b1.top();
            b1.pop();
            int x = cur.first, y = cur.second;
            if (x == now)swap(x, y);
            if (sn) {
                sn--;
                cout<<x<<" "<<x<<'\n';
                cout<<y<<" "<<y<<'\n';
            } else {
                cout<<x<<" "<<y<<'\n';
            }
            now = y;
        }

    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T = 1;
//    cin>>T;
    while (T--)solve();

    return 0;
}

E-Malfunctioning Typewriter

跑一个字典树，n个串都得出现一次，相当于每个结点都会跑过对应的次数，每个节点对答案的贡献是独立的，相当于是它的左右儿子的01的个数对应的概率，这个概率可以预处理出来。

#include <bits/stdc++.h>

using namespace std;
#define int long long
const int N = 2e6 + 100;
const int mod = 1000000007;
const int INF = 0x3f3f3f3f;

int n,m;
double p ;

double f[2020][2020];
int tire[N][3];
int tot =0 ;
int siz[N];

void insert(string s){
    int id = 0 ;
    for(int i=0;i<s.size();i++){
        int val =s[i]-'0';
        if(tire[id][val] ==0 ){
            tire[id][val] = ++tot;
        }
        id = tire[id][val];
        siz[id]++;
    }
}
double ans ;
void dfs(int p){

    int siz1 = siz[tire[p][1]],siz0=siz[tire[p][0]];
    ans *= (f[siz1][siz0]);

    if(siz1)dfs(tire[p][1]);
    if(siz0)dfs(tire[p][0]);
}

void solve() {
    cin>>n>>m>>p;

    f[0][0] = 1;
    for(int i=1;i<=n;i++){
        f[i][0] = f[i-1][0] * p;
        f[0][i] = f[0][i-1]* p;
    }
    for(int i=1;i<=n;i++){

        for(int j=1;j<=n;j++){
            f[i][j] = max((p)*f[i-1][j] + (1-p)*f[i][j-1] ,(1-p)*f[i-1][j] + (p)*f[i][j-1] );
        }
    }

    ans = 1;
    for(int i=1;i<=n;i++){
        string s;
        cin>>s;
        insert(s);
    }

    dfs(0);
    cout<<fixed<<setprecision(12)<<ans<<endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
//    cin >> t;
    while (t--) solve();

    return 0;
}

H-Rectangle Intersection

对于每一个方格，它所在的最小的交集是它上下左右离它最近的矩形包围而成的，但暴力时间不够。

可以发现一整块的这种贡献，是可以用它所在的交集的一个角来代替的，可以用前缀和的思想，找到这些边界点求答案。

0123分别表示上下左右

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=2e3+50;
int s[4][N][N];
int n,m,k,lx,ly,rx,ry;
int ans=1e15;
void solve(){
    cin>>n>>m>>k;
    for(int i=0;i<=k;i++){
    	if(i==0) lx=1,ly=1,rx=n,ry=m;
		else cin>>lx>>ly>>rx>>ry;
    	s[0][lx][ry]++,s[0][rx+1][ry]--;
    	s[1][lx][ly]++,s[1][rx+1][ly]--;
    	s[2][lx][ly]++,s[2][lx][ry+1]--;
    	s[3][rx][ly]++,s[3][rx][ry+1]--;
	}
	for(int i=0;i<=1;i++)
		for(int j=1;j<=n;j++)
			for(int k=1;k<=m;k++)
				s[i][j][k]+=s[i][j-1][k];
    for(int i=2;i<=3;i++)
		for(int j=1;j<=n;j++)
			for(int k=1;k<=m;k++)
				s[i][j][k]+=s[i][j][k-1];

	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(s[1][i][j]&&s[2][i][j]){
				int x=i,y=j;
				int len1=1,len2=1;
				while(!s[0][i][y]) y++,len1++;
				while(!s[3][x][j]) x++,len2++;
				ans=min(ans,len1*len2);
			}
		}
	}
	cout<<ans;
}
signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int _=1;
//    cin>>_;
    while(_--)
    solve();
    return 0;
}

J-Rigged Games

先处理出从每一个点开始，下一次赢下一个小局是在哪个点，（可以双指针O（n），赛时用二分多了个log）然后用倍增+二分求出答案，赛时这里二分的是跳几次，其实去算什么时候达到B的话也可以不用二分（类似于LCA时先跨大步后跨小步的做法）

多了两个二分的代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef  long long ll;
const int N = 1e6+10;

string s;
int sum1[N],sum0[N];
int a[N][25],b[N][25];

int n,aa,bb;
int  check(int k,int x){
    int res=0;
    for(int i=0;i<=20;i++){
        if((x>>i)&1){
            res+=b[k][i];
            k=a[k][i];
        }
    }
    if(res>=bb)return 1;
    else if((x-res>=bb))return 0;
    else return -1;
}
void solve(){

    cin>>n>>aa>>bb;
    cin>>s;
    string tt=s;
    while(s.size()< n+3*aa+1){
        s=s+s;
    }
    sum1[0]=sum0[0]=0;
    for(int i=0;i<s.size();i++){
        sum1[i+1] =sum1[i];
        sum0[i+1]=sum0[i];
        if(s[i]=='0')sum0[i+1]++;
        else sum1[i+1]++;
//        if(i<=20)cout<<i<<' '<<sum0[i]<<'\n';
    }
    for(int i= 1;i<= n;i++){
//    cout<<"sum0"<<sum0[i]<<endl;
        int l = i  ,r = (int)s.size();

        while(l<=r){
            int mid =(l+r)/2;
            int y1 = sum1[mid] -sum1[i-1];
            int y0 = sum0[mid] -sum0[i-1];

            if(y1>=aa ||y0>=aa)r=mid-1;
            else l =mid+1;
        }
        a[i][0] = (l)%n+1 ;

        int y1 = sum1[l] - sum1[i-1];
//        int y0 = sum0[l] -sum0[i-1];
//        cout<<i<<" "<<l<<':'<<y1<<' '<<sum0[l]<<' '<<sum0[i-1]<<'\n';
        if(y1>=aa)b[i][0]=1;
    }

        for(int i=1; i<=20; i++){
            for (int j = 1; j <= n; j++) {
            a[j][i]=a[a[j][i-1]][i-1];
            b[j][i]=b[j][i-1]+b[a[j][i-1]][i-1];
        }
    }
    for(int i=1;i<=n;i++){
        int l=bb,r=2*bb,mid;
        while(l<=r){
            mid=(l+r)/2;
            if(check(i,mid)!=-1)r=mid-1;
            else l=mid+1;
        }
        cout<<check(i,l);
    }


}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T=1;
//    cin>>T;
    while(T--)solve();

    return 0;
}

L-Sudoku and Minesweeper

找个不在边界的8就好了

#include<bits/stdc++.h>
#define int long long
using namespace std;
int mp[100][100];
string s;
int x,y;
void solve(){
	for(int i=1;i<=9;i++){
		cin>>s;
		for(int j=1;j<=9;j++){
			mp[i][j]=s[j-1]-'0';
		}
	}
	for(int i=1;i<=9;i++){
		for(int j=1;j<=9;j++){
			if(mp[i][j]==8&&i<=6&&i>=4&&j<=6&&j>=4){
				x=i,y=j;
				break;
			}
		}
	}
	for(int i=1;i<=9;i++){
		for(int j=1;j<=9;j++){
			if(i==x&&j==y) cout<<8;
			else cout<<'*';
		}
		cout<<'\n';
	}
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	int _ = 1;
//	cin >> _;
	while (_--) solve();
	return 0;
}

心刍
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2024牛客暑期训练营第一场
07-22
### 2024牛客暑期训练营第一场补题报告关键知识点解析 #### 题目C: Accept **核心思想**: 维护序列总和及其权值变化。 **详细解析**: - **背景**: 给定一个序列 `a[1], a[2], ..., a[n]` 和一系列操作，每轮操作...
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
3. 有向图的生成树计数(Domino Flip Graphs): 提到了Domino翻转图中的距离计算，可以通过"Lagrange Duality"证明，答案是b的转置乘以矩阵A的逆再乘以b。这在图论和网络流问题中常见。 4. 二次型(Quadratic Form): ...
2024牛客暑期多校第一场补题报告
xhg420的博客
07-18 194
题目类型：签到，数学。解题思路：题目要求输出每次操作后当前序列后缀和的和，可以发现每个ai在总和中出现i次，维护一个数组存放i*ai的前缀和即可。
题解：2024牛客暑期多校第2场——H [Instructions Substring]
华鑫的专栏
07-19 488
7月初投了，十天左右一面，hr，问了一些基本情况，比如为什么来合肥，对半导体工艺的了解，如果遇到问题。bg中游双2，山东人。计算机学硕，研究方向是AI视觉，有一篇顶刊在投，七成把握能中，想过去大厂算法或。本人双2，两个公司都在北京，航天智信据说出差 #如果可以选，你最想去哪家公司# 加班会多一些，中冶京。24届应届生，看破互联网了，身边同学没一个搞互联网的，都是高薪，有得去顺丰当管培生了，目前反正就是都。成都双非二本大三，目前在一家省属国企的开发部实习做测试，专业主要学了机器学习，大数据分析，机器视觉。
2024牛客暑期多校训练营1
2301_80085990的博客
07-17 447
2024牛客暑期多校集训营1 A. A Bit Common C. Sum of Suffix Sums H. World Finals
2024牛客暑期多校1（新手题）
2301_79902706的博客
07-18 1010
有两场World Finals同时举办，每场都有若干出线队伍，两场出线名单可能有重复的队伍，而一个队伍只能选择其中的一场参加，然后每场比赛的每支队伍都有一个预测成绩（过题数+ 罚时）lzr010506在两场World Finals 都出线了，他想知道如果所有队伍的最终成绩就是预测成绩，并且可以任意分配两场都出线了队伍的比赛场次的选择，他们队最高可能的排名是多少（1 ≤ number of teams ≤ 10^5）公式：C(k,n)×2^((m-1)(n-k))×(2^k-1)^(m-1)
题解：2024牛客暑期多校第2场——A [Floor Tiles]
华鑫的专栏
07-20 743
非技术投递记录# 7.10投递的，投了改了两次都被挂，突然感觉大概率是因为简历的问题，或者就是他们。Vue.js 3中的Teleport组件是一种特殊的组件，它允许我们将组件的内容渲染到DOM树中的指。#机械制造笔面经#机械制造投递记录# 不同于牛客上的很多大佬，我的学历很一般，纯传统方向，基本上卡学。#机械制造投递记录# #机械制造笔面经# 不同于牛客上的很多大佬，我的学历很一般，纯传统方向，基本上。双非研二，准备投c++方向岗位，之前没有实习经历，刚收到网新恒天的实习，现在已经7月下旬了，快秋招了。
题解：2024牛客暑期多校第2场——C [Red Walking on Grid]
华鑫的专栏
07-19 967
各位有什么建议吗，对于秋招，希望能得到牛友的指点之前每天忙导师连环杂活，完全没时间准备简历和面试，到。在美团的测开实习快三个月了，说下感受吧。实习期的工作主要是mentor安排的，不同的组，不同的men。下学期双非大三，大数据专业，有javase基础，目前在自学，大学期间只跟着导师做了机器学习深度学习的。北京的应届生落户政策今年取消了，想润上海了，请问现在上海有什么提前批可以投，或者可以帮我内推的吗，万。天美j3技术美术，是不是凉了啊，问hr说是面试官还没填面试结果，也没有短信来，有没有腾讯的小伙伴解答。
2024牛客暑期多校训练营3 - A(Bridging the Gap 2)
wxy_27的博客
07-23 155
n 个人 每个人的耐力值为a[i], 一条船至少有L个人至多有R个人,每次去河对岸要花费船上每个的的1点耐力值,问n个人能否去河对岸？输入的第一行包含三个整数n,L,R (1
2024牛客暑期多校训练营1 B题
hhhh3356的博客
07-17 690
题面：给定n,m,q,构造一个长度为n的数组，其中数组中的每个元素大小均小于，若该数组的中，所有元素按位与(AND)之后的结果为1，则该数组合法。求有多少种合法数组例如n=3,m=3,q=100000[1,0,3]是一个合法数组，因为子序列[1]的AND结果为1[5,3,0]是一个合法数组，因为子序列[5,3]的AND结果为1。
2024牛客暑假多校训练营2——两道入门DP（C题，I题）选讲
华鑫的专栏
07-18 563
你合入的代码越多，可能会带入的bug也就越多，带入的bug越多，你要解bug合入的代码也就越多。做成事儿的道、法、术～1、首先，做一件事儿时，要去灵魂拷问自己，为什么要做，发心不对，动作变形，没法。终于明白了递归和动态规划的区别，不愧是群众严选，把通过率50以上的题都做完了，继续加油，简单题信心很。#软件开发笔面经#6.1北京时间上午10点一面简单自我介绍，项目介绍----------------方法：递归+回溯 n对括号的生成就是n个左括号和n个右括号组成的合法排列，在使用了一个。
2024牛客暑期多校训练营1 A题
hhhh3356的博客
07-16 163
若该数组的某一个子序列中，所有元素按位与(AND)之后的结果为1，则该数组合法。题面：给定n,m,q,构造一个长度为n的数组，其中数组中的每个元素大小均小于。[5,3,0]是一个合法数组，因为子序列[5,3]的AND结果为1。[1,0,3]是一个合法数组，因为子序列[1]的AND结果为1。那么某位至少有一个0，也就是不能全1，也就是该位可以填的数有。找到子序列中，恰好有i个元素相与为1，多一个都会出错。个，而总共有(m-1)位这样的位置，总共可以填的数量为。例如n=3,m=3,q=100000。
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 693
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 289
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
Codeforces Round 961 (Div. 2)
2301_80105412的博客
07-24 994
Codeforces Round 961 (Div. 2) ABC
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 329
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

心刍

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

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

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

打赏作者

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

抵扣说明：

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

余额充值