目录
逃课(不是)
难度:白银
时间限制:1秒四占用内存:128 M
哪怕是小码哥，也存在想要逃课的时候(不知道被谁带坏了)。
现在，他决定逃掉一些课，每一节课都有它的种类和疲劳度，只要上了某节课，小码哥就会获得一些疲劳度。但由于还存在理智，小码哥知道不能逃两节种类相同的课(会被老师发现)。现在请你帮小码哥设计逃课计划，使得他的疲劳度最小。
PS:小码哥才不会逃课!逃课的都是坏孩子!逃课仅仅是想法而已嘿嘿嘿，新年还是要学习的!
格式
输入格式:第一行一个整数 n ，表示课的数目;
接下来 n 行每行两个数 ai，wi，表示这节课的种类和疲劳度。
输出格式:一行一个整数表示最少的疲劳度。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 +7;
struct NODE {
long long a, w;
}node[N];
long long n,sum,ans;
bool cmp(NODE n1,NODE n2) {
if (n1.a < n2.a)
return true;
if (n1.a == n2.a && n1.w <= n2.w)
return true;
return false;
}
int main(){
cin >>n;
for(int i=1;i <= n;i++) {
cin >> node[i].a >> node[i].w;
sum += node[i].w;
}
sort(node +1,node +n +1,cmp);
NODE temp = node[0];
for(int i=1;i<=n+1;i++){
if (node[i].a != temp.a)
ans += temp.w;
temp = node[i];
}
cout << sum -ans;
return 0;
}
水温调节
少 难度:黄金
时间限制:1秒四:占用内存:128 M
小码哥家里的浴缸有一个冷水龙头和一个热水龙头，流出的水温分别是t和t;它们的流速最大是每秒1和2个单位，并且可以调节到0至最大流速间的任意一个整数速度。假如两个龙头的流速分别是y和y(0≤y1,y≤10)，那么最终的水温就是t=y+tz华y1十y2
现在，小码哥请你帮忙安排两个水龙头的流速，满足:1.最终水温不低于 to;
2.在满足上一条的前提下，水温尽可能接近 to;3.在满足上一条的前提下，总流速尽可能大。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
double t1,t2,x1,x2,t0;
//输入格式
double y1,y2,t;
//过程变量
double tmax = 0x3f3f3f3f,ans1,ans2;//结果值
cin>>t1>>t2>>x1>>x2>>t0;
y1 = x1,y2=x2;
while(y1>=0&&y2>=0){
t=(t1*y1+t2*y2)/(y1+y2);
if(t>=t0) {
if (t < tmax)
tmax = t, ans1 = y1, ans2 = y2;
y2--;
}else
y1--;
}
cout << ans1<<" "<<ans2;
return 0;
}
中暑的竹鼠
巴 占用内存:256 M少难度:黄金 时间限制:3秒
夏天来了，竹鼠们中暑了，小码哥要挨个“照顾”这些竹鼠，使它们恢复健康
已知一共有 N 只竹鼠中暑，每个竹鼠需要的照顾时间是工，请问怎么排列这N 只竹鼠的照顾次序，可以使 N 只竹鼠的平均等待时间最短。
格式
输入格式:第一行为一个整数 N;
第二行 N 个整数，第讠个整数 T 表示第讠个人的照顾时间。其中:0<N<500，T<105
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int M = 507;
int N,T[M],ans;
int main(){
cin >>N;
for (int i = 1;i<=N;i++)
cin >> T[i];
sort(T + 1,T + N + 1);
int temp =0;
for (int i=1;i<=N;i++) {
temp += T[i - 1];
ans += temp;
}
double ans2 = (double)ans / N;
printf("%.2lf",ans2);
return 0;
}
竹鼠发瓜子
乡难度:黄金时间限制:3秒巴 占用内存:128 M
今天小码哥和小码弟兄弟俩打算给竹鼠们发瓜子吃。竹鼠们排成一列纵队，兄弟俩会根据竹鼠的体重来评定发瓜子的数量。
其中第之个竹鼠的体重是 ai，发瓜子时需要满足以下要求:
1.相邻竹鼠中体重高的竹鼠的瓜子必须更多，若它们体重相等，则它们分到的瓜子数量必须相等2.每只竹鼠至少有一个瓜子。
3.因为经费有限，在满足条件1和2的前提下，发出尽可能少的瓜子。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 +7;
int n,ans,wt [N],num[N];
int main(){
cin >>n;
for (int i=1;i <=n;++i)
cin >> wt[i];
for (int i=1;i<n;++i)
if (wt[i]<wt[i+1])
num[i+1]= num[i]+1;
else if (wt[i]==wt[i+1])
num[i+1]=num[i];
for (int i=n;i>=1;--i)
if (wt[i -1] > wt[i])
num[i - 1] = max(num[i-1],num[i] + 1);
for (int i=1;i<=n;++i)
ans += num[i];
cout << ans +n;
return 0;
}
竹鼠发瓜子(二)
难度:黄金巴 占用内存:128 M时间限制:3秒
小码哥一口气买了一包有 m 颗瓜子的qiagia瓜子，现在要把这些瓜子分给 n 只竹鼠。
每只竹鼠都有一个瓜子的期望值，如果没有达到竹鼠的期望值，竹鼠就会生气，竹鼠生气的程度等于它少得到瓜子数的平方。
小码哥要合理分配瓜子，使竹鼠们生气的程度之和最小。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1e5 +7;
ll m,n,a[N],ans;
int main(){
cin >>m >>n;
ll sum=0;
for (int i=0;i<n;i++){
cin >>a[i];
sum += a[i];
}
sum -=m;
sort(a,a + n);
for (int i=0;i<n;i++) {
ll w = min(a[i], sum / (n - i));
ans += w * w;
sum -= w;
}
cout << ans;
return 0;
}
检测敌人
难度:钻石时间限制:1秒巴 占用内存:128 M
在一片废墟里埋藏着许多敌人，他们在隐逸状态下，不能被发现，于是小码哥被派遣去放置装置持续地检测敌人，但是这个公园只有一条笔直的马路，小码哥有许多装置可以放置在马路上，它能搜寻出以装置为中心的半径为"以内的圆里敌人(包括边界)，我们使用直角坐标系，定义马路为:轴，马路两边分别为y的正半区和y的负半区，现在给出每个敌人的具体坐标以及装置的检测范围，请你求出能够使所有敌人都被装置覆盖所需的最小装置数目。
格式
输入格式:可能存在多组数据。
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 1007;
struct ENEMY {
double x, y, right, left;
bool v;
};
// Correct the comparison to sort by the right coordinate
bool cmp(const ENEMY &a, const ENEMY &b) {
return a.right < b.right;
}
int main() {
int n;
double r;
vector<ENEMY> e(N); // Use vector instead of plain array for automatic initialization
while (cin >> n >> r && !(n == 0 && r == 0)) {
bool flag = false;
// Input for enemies
for (int i = 1; i <= n; i++) {
cin >> e[i].x >> e[i].y;
if (r * r < e[i].y * e[i].y) {
flag = true; // Mark flag as true if enemy is out of radar range
} else {
// Compute the radar coverage interval for each enemy
double dx = sqrt(r * r - e[i].y * e[i].y);
e[i].left = e[i].x - dx;
e[i].right = e[i].x + dx;
e[i].v = false;
}
}
// If any enemy is out of radar range, print -1
if (flag) {
cout << -1 << endl;
continue;
}
// Sort enemies based on the right coordinate
sort(e.begin() + 1, e.begin() + n + 1, cmp);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!e[i].v) { // If the enemy is not yet covered
for (int j = i; j <= n; j++) {
// Mark all enemies covered by the radar at position i
if (!e[j].v && e[j].left <= e[i].right) {
e[j].v = true;
}
}
ans++; // Increment the number of radars needed
}
}
cout << ans << endl; // Output the result
}
return 0;
}
小码哥的福利
乡 难度:钻石时间限制:1秒四 占用内存:128 M
小码哥的手下越来越多，享受的福利待遇却不太一样，小码哥经常用甜品来奖励他的手下，他希望他们吃到的甜品数量可以一起平均增长，小码哥知道现在这些手下的甜品耐受度为 a，手下可以吃掉小于等于他甜品耐受度的甜品(只要一个甜品的甜度小于等于某个手下的甜品耐受度，这个手下就有能力吃掉它)，如果某一个手下吃掉了一个甜品，这个手下吃过的甜品数量就会 +1; 现在小码哥知道甜品的甜度 b; 和数量 G，他希望可以在吃掉所有甜品的情况下(小码哥不喜欢浪费)，使这些手下中吃掉的甜品数量最大的人吃掉的数量尽可能的小。 如果不能吃掉所有的甜品则输出 -1 ，否则输出最小化最大的吃掉的数量。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool canDistribute(vector<int>& tolerances, vector<int>& sweetness, vector<int>& amounts, int maxCandies) {
int n = tolerances.size();
int m = sweetness.size();
vector<int> maxEat(n, 0); // 每个手下可以吃的最大数量
for (int i = 0; i < m; ++i) {
int totalCandies = amounts[i]; // 第i种甜品的总数量
for (int j = 0; j < n && totalCandies > 0; ++j) {
if (sweetness[i] <= tolerances[j]) { // 如果手下j可以吃这种甜品
int eat = min(maxCandies - maxEat[j], totalCandies); // 他最多还能吃多少
maxEat[j] += eat;
totalCandies -= eat;
}
}
if (totalCandies > 0) return false; // 如果还有剩余，说明无法分配完
}
return true; // 所有甜品都能被分配完
}
int main() {
int n;
cin >> n; // 手下的数量
vector<int> tolerances(n);
for (int i = 0; i < n; ++i) {
cin >> tolerances[i];
}
int m;
cin >> m; // 甜品种类数
vector<int> sweetness(m);
vector<int> amounts(m);
for (int i = 0; i < m; ++i) {
cin >> sweetness[i];
}
for (int i = 0; i < m; ++i) {
cin >> amounts[i];
}
// 排序耐受度以优化分配过程
sort(tolerances.begin(), tolerances.end());
int left = 1, right = 1000000000, result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (canDistribute(tolerances, sweetness, amounts, mid)) {
result = mid; // 记录可能的最小结果
right = mid - 1; // 尝试更小的最大值
} else {
left = mid + 1; // 需要增加最大值
}
}
cout << result << endl;
return 0;
}
货物买卖
难度:黄金巴 占用内存:128 M时间限制:1秒
某条马路上有几个商铺，有些商铺出售物品，有些收购物品，所有物品的价值都是相同的，每一种物品都被大家接受并且可以用来交易。
我们把这条马路看作一个x轴，小码哥从这条马路的起点出发(即原点)，每个商铺的坐标是确定的，他在前进过程中会经过所有的商铺，并且在第几个商铺处停下。
我们已知这些商铺出售的货物之和是大于等于收购的货物之和的，即所有的商铺的需求都可以被满足。小码哥与他们交易不需要时间，而每在轴上行走一步就需要1单位时间。
小码哥在初始时手上没有货物，他不能卖给某个商铺超过他手上货物总量的货物，且是否买卖货物由他自己决定，但他必须满足所有商铺的需求，他想知道他最少需要花费多少时间。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N=307;
struct SHOP {
int position, need;
}shop[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> shop[i].position;
for (int i = 1; i <= n; i++)
cin >> shop[i].need;
int carry = 0, owe = 0, owe_x = 0, ans = 0;
for (int i = 1; i <= n; i++) {
if (shop[i].need < 0) {
owe = owe + shop[i].need;
if (owe_x == 0)
owe_x = shop[i].position;
} else {
carry = carry + shop[i].need;
}
if (carry >= -owe && owe != 0) {
ans = ans + (shop[i].position - owe_x) * 2;
owe_x = 0;
carry = carry + owe;
owe = 0;
}
}
cout << ans + shop[n].position;
return 0;
}
仙水购置
少 难度:钻石 时间限制:1秒巴 占用内存:128 M
小码哥有 N 个瓶子，都是由十分珍贵的材料制作的，所以他一直只有 N 个，以至于当他需要多于 N 种的仙水时，不得不把某一种仙水倒掉来盛放最新需要的仙水。
现在小码哥需要完成一项工作，需要使用瓶子的仙水，如果瓶子里缺少当前需要的仙水，他就会去购买,初始他的瓶子里没有任何一种仙水。
现在给定一个小码哥需要的长度为p的仙水序列，问小码哥至少需要购买多少次仙水?如果瓶子里没有小码哥需要的仙水，他不得不倒掉某一种，但不清楚应该倒哪一种，你可以帮小码哥决定倒哪一种，来使他购买仙水的次数最少。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 7;
int n,m,p,a [N],vis[N],nextID[N],last [N];
priority_queue<pair<int,int>>l;
int main(){
while (cin >>n >>m >>p){
while (!l.empty())
l.pop();
memset(vis,0,sizeof(vis));
memset(nextID,0,sizeof(nextID));
memset(last,50007,sizeof(last));
for (int i=1;i <= p;i++)
cin >>a[i];
for (int i=p;i>=1;i--){
nextID[i] = last[a[i]];
last[a[i]] = i;
}
int ans =0;
for (int i=1;i<=p;i++){
if (ans <n && !vis[a[i]]) {
ans++;
vis[a[i]] = 1;
}else if (ans >=n && !vis[a[i]]){
ans++;
vis[l.top().second] = 0;
vis[a[i]] = 1;
l.pop();
}
l.push({nextID[i],a[i]});
}
cout <<ans <<endl;
}
return 0;
}甜品供应
少难度:钻石时间限制:1秒巴 占用内存:128 M
小码哥的 C 个手下有着不同的甜食喜好程度，而对于一个甜食来说，可以用一个数字”来表示他的甜度。
小码哥的手下对于一定区间的甜度的甜品表示喜欢。对于一个编号为i的手下，他的甜品喜爱区间为L,"i]，但如果超过或小于这个区间的甜品则表示讨厌，并影响当天的上班心情。小码哥为了使上班的工作效率最大，购置了一批甜品，有种，甜度为的甜品有num;个。
请问小码哥最多可以使多少人吃到喜欢的甜品?
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 +7;
struct PEOPLE{
int l,r;
bool operator<(const PEOPLE &a) const{
if (l ==a.l)
return r<a.r;
return l<a.l;
}
}people [N];
struct SWEET{
int v,num;
bool operator>(const SWEET &a)const {return v>a.v;}
};
int C,L,cnt[N],ans;
priority_queue<SWEET,vector<SWEET>,greater<SWEET>>q;
int main(){
cin >>C >>L;
for (int i=1;i<=C;i++)
cin >>people[i].l>>people[i].r;
sort(people +1,people +1+C);
for (int i = 1;i<=L;i++){
SWEET t;
cin >>t.v>>t.num;
cnt[t.v]+= t.num;
q.push(t);
}
for (int i=1;i<=C;i++){
while ((!q.empty())&& q.top().v < people[i].l)
q.pop();
if (!q.empty() && q.top().v<=people[i].r){
ans++;
cnt [q.top().v]--;
if (cnt[q.top().v]==0)
q.pop();
}
}
cout <<ans;
return 0;
}
活动安排
难度:黄金 时间限制:1秒巴 占用内存:128 M
小码哥又被安排去处理公司大厅事项了，公司只有一个大厅，但有许多的活动需要召开，所以需要提前预约，该公司有n个部门，每个部门会举办一个活动。每个部门会向小码哥上报他们预期使用大厅的时间区间(,b)(开区间)，小码哥会根据时间做安排，一个时间只能有一个活动在召开，活动一旦开始必须结束才能进行下一个活动。
小码哥想要尽可能多的满足活动的召开，于是请你来帮忙安排活动。
格式
输入格式:第一行一个整数 n，代表部门的个数;接下来的 n 行，每行两个整数 a，b，代表时间区间。
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int N=5e5 + 7;
int n,ans;
struct NODE{
int l,r;
}node[N];
bool cmp(NODE a,NODE b){return a.r<b.r;}
int main(){
cin >>n;
for (int i=1;i<=n;i++)
cin >>node[i].l>> node[i].r;
sort(node +1,node +1 + n,cmp);
int temp =0;
for (int i=1;i <=n;i++)
if (node[i].l>=temp){
temp = node[i].r;
ans++;
}
cout <<ans <<endl;
return 0;
}
屠龙勇者
难度:黄金巴: 占用内存:128 M时间限制:1秒
很久很久以前，巨龙突然出现，带来灾难带走了公主又消失不见。后来，一名叫做小码哥的勇者战胜了巨龙，拯救了王国。现在，一头更可怕的多头喷火龙使王国再次面临毁灭。巨龙有n个头，每个头的直径为d，而国王有个勇士，每个勇士最多只能砍一个头，且能力值为的勇士只能砍下直径不超过w的龙头。现在请你计算这些勇士能否消灭这只巨龙。
格式
输入格式:输入共三行，第一行两个正整数 n,m 满足 0<n,m ≤1x105第二行 n 个正整数 d;
第三行 m 个正整数 i ，满足 0< di, wi,<1x 108
//
// Created by abner on 2024/4/26.
//
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 +5;
int a[maxn],b[maxn],n,m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= m; ++i)
cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
if (n > m) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; ++i) {
if (b[i + m - n] < a[i]) {
cout << "NO";
return 0;
cout << "YES";
return 0;
}
}
cout << "YES";
return 0;
}
扫一扫
609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
