牛客欢乐赛1

最新推荐文章于 2024-07-15 22:10:26 发布
最新推荐文章于 2024-07-15 22:10:26 发布
阅读量174 收藏
点赞数 1
分类专栏： 牛客寒假算法基础训练营 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40184139/article/details/117152873
版权

牛客欢乐赛1

比赛地址

A

​ 自己最开始想着这什么鬼，把石子在数轴上排序，然后枚举距离看是否满足条件，再一看距离好家伙任意实数，属实不能做。就放弃了。

​ 正确的做法倒是也很简单，我们举一个例子来说的话

在这里插入图片描述

​ 我们不用考虑具体的中心位置设置在哪里，对于上图而言我只需要把中心位置设置的离第一个红色球更近就可以满足条件，求出来最大是4个。所以问题就转化成了，需要考虑在两个相邻的蓝球中的最多红球的个数。但是需要注意左边没有蓝球以及右边没有蓝球的两种特殊情况。

​ 得到上述的结论之后就是来计算了，最开始自己写的是蓝红分为两个数组，然后进行遍历。最后超时。这里采用分组过后可以采用STL中的lower_bound与upper_bound

lower_bound

lower_bound(起始地址，结束地址，要查找的数值) 返回的是数值 第一个 出现的位置。

upper_bound

upper_bound(起始地址，结束地址，要查找的数值) 返回的是 第一个大于待查找数值 出现的位置。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> red;
vector<int> blue;

int t,n,m;
bool cmp(int a,int b){
    return a < b;
}

void work(){
    sort(red.begin(),red.end(),cmp);
    sort(blue.begin(),blue.end(),cmp);
    int cnt = 0;
    int ans = -1;
    for(int i = 0;i < blue.size() - 1;i++){
        int l = blue[i];
        int r = blue[i + 1];
        cnt = lower_bound(red.begin(),red.end(),r) - lower_bound(red.begin(),red.end(),l + 1);
        ans = max(ans,cnt);
    }
    if(ans == 0){
        printf("Impossible\n");
    }else{
        printf("%d\n",ans);
    }
}

void input(){
    scanf("%d",&t);
    int s;
    while(t--){
        scanf("%d%d",&n,&m);
        red.clear();
        blue.clear();
        for(int i = 0;i < n;i++){
            scanf("%d",&s);
            red.push_back(s);
        }
        for(int i = 0;i < m;i++){
            scanf("%d",&s);
            blue.push_back(s);
        }
      	//处理两种特殊情况
        blue.push_back(0);
        blue.push_back(1e9+10);
        work();
    }
}


int main(){
    input();
    return 0;
}

除了两个数组排序之外，还可以使用map的方法解决

#include <cstdio>
#include <map>
using namespace std;
map<int,int> pos,cnt;
int t,n,m;


void work(){
    int max = -1;
    int ans = 0;
    for(auto &it:pos){
        if(it.second == 1){
            ans += cnt[it.first];
        }else{
            max = max > ans ? max : ans;
            ans = 0;
        }
    }
    max = max > ans ? max : ans;
    if(max == 0){
        printf("Impossible\n");
    }else{
        printf("%d\n",max);
    }
}

void input(){
    scanf("%d",&t);
    while(t--){
        pos.clear();
        cnt.clear();
        scanf("%d%d",&n,&m);
        for(int i = 0;i < n;i++){
            int s;
            scanf("%d",&s);
            pos[s] = 1;
            cnt[s]++;
        }
        for(int i = 0;i < m;i++){
            int s;
            scanf("%d",&s);
            pos[s] = 0;
            cnt[s] = 0;
        }
        work();
    }


}

int main(){
    input();
    return 0;
}

B

​ 对于这道题来说，我们可以很方便地根据上一行的数据来推断出这一行的状态，例如

在这里插入图片描述

比如这里我们假设第一列第一行有雷，那么根据第二列的第一行我们可以知道第二行是没有雷的，根据第二行我们可以得到第三行是有雷的，那么第四行就是没雷的。那么我们还可以假设第一行是没有雷的。这样的流程过后，我们会发现，只要第一行的状态是确定的，那么其余行的状态是可以推出的，也就是确定的。所以答案要么是1要么是2（第一行没雷或者有雷）。假定完之后，判断一下是否冲突即可。

#include <cstdio>
#include <algorithm>
using namespace std;

int n;
int a[10010];
int l[10010];

int cal(){
	for(int i = 0;i < n - 1;i++){
		int left;
		if(i == 0){
			left = a[i] - l[i];
		}else{
			left = a[i] - l[i] - l[i - 1];
		}
		if(left == 1){
			l[i + 1] = 1;
		}else if(left == 0){
			l[i + 1] = 0;	
		}else{
			return 0;
		}
	}
	if(a[n - 1] == l[n - 1] + l[n - 2]){
		return 1;
	}else{
		return 0;
	}
}

void work(){
	int ans = 0;
	l[0] = 1;
	if(cal()) ans++;
	l[0] = 0;
	if(cal()) ans++;
	printf("%d",ans);
}

void input(){
	scanf("%d",&n);
	for(int i = 0;i < n;i++){
		scanf("%d",&a[i]);
	}
}

int main(){
	input();
	work():
	return 0;
}

C

​ 在这里我们首先考虑没有施法的情况，对于每一个糖糖，只要有跟他不同组的糖糖在他的后面，且能力值大于它，它就会死。那么我们只需要从后往前遍历，同时维护两个组的最大值。每次遇到一个糖糖的时候就用它和另一组的最大值进行比较，只要小于，糖糖就会死。

​ 我们再考虑施法的情况，在施法的时候，其实是对前面的序列造不成影响的，因为这部分的大小关系是不会改变的，改变的只有后半部分之间的关系。而我们每一次是只判断前半部分的关系。所以这里逐步施法跟放在一起施法是没有影响的。

​ 每次施法的处理，这里如果使用for循环的话就会导致超时，这里就用到了差分数组，记录下相邻两个数字的差值，每一次施法的时候，施法处的差值-1，由于每一次都是从1到x加1，所以这里就使最开头的差值++就可以了

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

typedef struct{
    int no;
    int ability;
}child;

vector<child> temp;
int delta[50007];


int t,n,m,ans;

void change(int time){
    for(int i = 0;i < time;i++){
        temp[i].ability++;
    }
}

void work(){
    int t[2] = {-1,-1};
    for(int i = n - 1;i >= 0 ;i--){
        int group = temp[i].no;
        if(t[1 - group] > temp[i].ability){
            ans--;
        }
        t[group] = max(t[group],temp[i].ability);
    }
    printf("%d\n",ans);
}

void input(){
    scanf("%d",&t);
    while(t--){
        temp.clear();
        scanf("%d%d",&n,&m);
        ans = n;
        for(int i = 0;i < n;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            child s;
            s.no = a;
            s.ability = b;
            temp.push_back(s);
            if(i > 0){
                delta[i] = temp[i].ability - temp[i - 1].ability;
            }
        }
        for(int i = 0;i < m;i++){
            int time;
            scanf("%d",&time);
            delta[0]++;
            delta[time]--;
        }
        for(int i = 0;i < n;i++){
            if(i == 0){
                temp[i].ability = delta[i] + temp[i].ability;
            }else{
                temp[i].ability = temp[i - 1].ability + delta[i];
            }
        }
        work();
    }
}


int main(){
    input();
    return 0;
}

D

​ 最开始看到还以为是搜索题，直接上手深度搜索，最后超时了。正解为动态规划题目。每次走到一个格子之后的状态与该格子之前的状态无关，仅与之后的状态相关，所以考虑用动态规划。这里走到的位置我们可以用$ i1+j2+k3+l4$来表示

d p [ i ] [ j ] [ k ] [ l ] = m a x ( d p [ i − 1 ] [ j ] [ k ] [ l ] , d p [ i ] [ j − 1 ] [ k ] [ l ] , d p [ i ] [ j ] [ k − 1 ] [ l ] , d p [ i ] [ j ] [ k ] [ l − 1 ] ) + a [ i ∗ 1 + j ∗ 2 + k ∗ 3 + l ∗ 4 ] dp[i][j][k][l] = max(dp[i-1][j][k][l],dp[i][j-1][k][l],dp[i][j][k-1][l],dp[i][j][k][l-1])+a[i*1+j*2+k*3+l*4] dp[i][j][k][l]=max(dp[i−1][j][k][l],dp[i][j−1][k][l],dp[i][j][k−1][l],dp[i][j][k][l−1])+a[i∗1+j∗2+k∗3+l∗4]

i,j,k,l分别表示的就是1，2，3，4四张卡片的数量，

#include <cstdio>
#include <algorithm>
#include <string.h>
using namespace std;

int a[357];
int dp[43][43][43][43];
int cnt[5];
int n,m;

int dfs(int i,int j,int k,int l){
    if(i < 0 || j < 0 || k < 0 || l < 0) return 0;
    if(dp[i][j][k][l] != 0) return dp[i][j][k][l];
    dp[i][j][k][l] = max(max(dfs(i - 1,j,k,l),dfs(i,j- 1,k,l)),
                         max(dfs(i,j,k - 1,l),dfs(i,j,k,l - 1)))
                    +a[i * 1 + j * 2 + k * 3 + l * 4];
    return dp[i][j][k][l];
}

void work(){
    printf("%d\n",dfs(cnt[1],cnt[2],cnt[3],cnt[4]));
}

void input(){
    scanf("%d%d",&n,&m);
    for(int i = 0;i < n;i++){
        scanf("%d",&a[i]);
    }
    memset(cnt,0,sizeof(cnt));
    for(int i = 0;i < m;i++){
        int temp;
        scanf("%d",&temp);
        cnt[temp]++;
    }
}

int main(){
    input();
    work();
    return 0;
}

E

我们在这里假定给定的区间为[l,r]，假设我们知道从l开始经过s个区间后的位置t,如果r大于t，那么我们就还需要向后找。当然这里不可能一个一个地找过去。在这里我们可以用二进制的表示。我们假设想找的范围在第一个数的第7个区间里。我们可以先到第一个数的第四个区间。从第四区间到第六区间，从第六区间到第七区间。即7 = 4 + 2 + 1。所以这里我们需要求的就是每一l第0，1，2，4。。。区间右边的位置。

#include <cstdio>
#include <algorithm>
using namespace std;


int n,m,k;
int a[1000100];
int f[1000100][23];

void input(){
    scanf("%d%d%d",&n,&m,&k);
    for(int i = 1;i <= n;i++){
        scanf("%d",&a[i]);
    }
}

void prework(){
    long long sum = 0;
    for(int j = 0;j <= 20;j++){
        for(int i = 1;i <= n + 1;i++){
            f[i][j] = n + 1;
        }
    }
    //求第0个区间
    for(int i = 1,j = 0;i <= n;i++){
        while(sum <= k && j <= n){
            ++j;
            sum += a[j];
        }
        f[i][0] = j;
        sum -= a[i];
    }
    //8 = 4 + 4
    //也就是为了求第i个区间转变成求j的i-1区间
    //和从i-1区间右边开始的i-1区间的和
    for(int i = 1;i <= 20;i++){
        for(int j = 1;j <= n;j++){
            f[j][i] = f[f[j][i-1]][i-1];
        }
    }
}

void calc(int l,int r){
    long long ans = 0;
    for(int i = 20;i >= 0;i--){
        if(r >= f[l][i]){
            ans += 1 << i;
            l = f[l][i];
        }
    }
    if(f[l][0] <= r) ans = -1;
    if(ans == -1){
        printf("Chtholly\n");
    }else{
        printf("%lld\n",ans + 1);
    }
}

void work(){
    for(int i = 0;i < m;i++){
        int l,r;
        scanf("%d%d",&l,&r);
        calc(l,r);
    }
}


int main(){
    input();
    prework();
    work();
    return 0;
}
TimeVshow
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
牛客. 青蛙树1
08-03
在这个问题中，给定一个长度为 N 的数组 [a1, a2, ..., aN]，我们需要处理 Q 次询问，每次询问要求计算一个子数组 [ali, ali+1, ..., ari] 内可以组成的小根堆的数量，同时满足这些堆在中序遍历时的顺序为 [li, li+1...
牛客刷题总结.docx
01-28
"牛客刷题总结" 本资源摘要信息主要涵盖了 Java 语言的基础知识点、设计模式和事务处理。下面是详细的知识点解释： 一、Java 基础知识 1. Java 源程序只能有一个 public 类存在，且类名与文件名相同。这是因为 ...
牛客欢乐赛1题解
weixin_45196541的博客
05-18 144
牛客欢乐赛1题解 目录 A题 B题 C题 D题 E题 A题： 给题目先： 题面有点长简单翻译一下题意： 数轴上有n个红色石子和m个蓝色石子，对于数轴上任意一个位置c，存在一个红色石子与c的距离比所有的蓝色石子都近则红队得一分，有n个则得n分，现在已知所有石子的位置，请找出一个位置c使得红队得分最多。 翻译成人话就是求最长连续的红色石子个数。 这是我们最容易想到的情况，但是有可能红蓝色石子放在同一位置。 则会出现如下状况 当处在箭头所指位置时，红色石子均不得分，因.
牛客欢乐赛1 E题
qq_45719639的博客
06-01 82
题意 思路 首先我们拿到这个题肯定想到的是暴力，也就是每次给一个区间[L,R],我们就枚举区间L,R，然后看需要分多少个段，这样的事件复杂度肯定是会超时的。 我们可以用二分+前缀和的方式枚举出每个点能取的最大右端点是什么，然后每次求[L，R]的时候就不用每个点都需要枚举，而是直接可以一个区间一个区间的去看。 这样的话其实是可以被卡成和暴力时间复杂度一样的，假如每个区间都只有一个值的话，那我们每次枚举的区间也就每次是一个值，和第一种情况是一样的。 倍增 我们可以维护出一个st[I][j]表，这个数组的含义
牛客欢乐赛1 D题（动态规划）
qq_45719639的博客
06-01 100
题意 思路 我们看数据范围知道，每一种卡片最多有40张，也就是说这四种卡片的所有情况是40∗40∗40∗40.40*40*40*40.40∗40∗40∗40.,我们并不好判断每次应该选那个点，我们唯一能知道的就是会经过最后一个点，到达最后一个点一共有四种情况，分别是从n-4到n，n-3到n，n-2到n，n-1到n，这四种情况，这种题一般都是要用到动态规划，用局部最优最后推出全局最优。 dp[i][j][k][l]dp[i][j][k][l]dp[i][j][k][l]表示已经用了i张1卡片，j张2卡片
牛客欢乐赛3 C题-背包
qq_45719639的博客
07-09 109
题意 给你一个价值为V的背包，给你n个物品，每一个物品都有一个价值和体积，让你求背包装m个物品时，背包里面中位数最大的值。 思路 当m为奇数的时候，我们很容易发现，背包中的中位数最大值肯定出现在n个物品中，所以我们可以直接枚举每一个物品，然后来判断当前背包是否可以满足条件，我们可以对n个物品按价值排序，这样当我们枚举到一个物品i的时候，我们只需要选出i前面的m2\frac{m}{2}2m​个物品的最小体积和i之后的m2\frac{m}{2}2m​的物品体积最小值，然后判断是否能选i这个物品为中位数。 当m为
“奔跑吧，牛客”比赛是一个面向全国高校学生、踏入职场2年以内的IT人员的赛事 .zip
09-30
比赛项目代码
关于牛客刷题总结全部汇总
02-21
关于牛客刷题总结全部汇总 本资源摘要信息主要讲述了 Java 语言的基本概念、设计模式、MVC 模式、数学函数、重载和重写的区别、多态、数组、静态成员和方法、事务属性等知识点。 一、Java 基本概念 1. Java 源...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 224
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 457
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 245
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
最新发布
2201_76027754的博客
07-15 786
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 482
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 323
手撕七大排序 （三）
【C++】B3716分解质因子3 题解_素数筛法_欧拉筛+埃氏筛_算法竞赛
YLCHUP的博客
07-14 713
洛谷B3716题解，一道巧妙的质数筛法变形题，讲解得很详细，适合中等水平学习。快来看ヾ(•ω•`)o
【JavaScript 算法】哈希表：快速查找与存储
Allen-
07-15 792
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
【算法/序列】等差数列&&子序列&&算术序列&&最长对称子串
island1314的博客
07-14 923
子序列：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。该题主要是求其满足等差性质的子数组个数，并且子数组在原数组的相对顺序不能变，并且。长度为3的子序列：（1，2，3）、（1，2，5）、（1，4，5）长度为1的子序列：（1）、（2）、（3）、（4）、（5）长度为2的子序列：长度为2的子序列都是算术子序列。：是数组中的一个连续序列。长度为4的子序列：0。长度为5的子序列：0。
【并查集缩点+tarjan无向图求桥】Where are you @牛客练习赛32 D
05-17
这道题是一个比较典型的无向图缩点和求桥的问题。 首先我们需要使用 Tarjan 算法求出无向图中的桥，即割边，这里就不再赘述了。 接下来我们需要对图进行缩点操作。具体地，我们使用并查集来维护每个点所属的连通块...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值