（AtCoder Beginner Contest 306）

最新推荐文章于 2024-11-08 13:43:44 发布
最新推荐文章于 2024-11-08 13:43:44 发布
阅读量383 收藏
点赞数
文章标签： python java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61657632/article/details/131266888
版权

A.直接模拟吧不解释了

import random
import sys
import os
import math
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from io import BytesIO, IOBase
from copy import deepcopy
import threading
import bisect

BUFSIZE = 4096


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def I():
    return input()

def II():
    return int(input())

def MI():
    return map(int, input().split())

def LI():
    return list(input().split())

def LII():
    return list(map(int, input().split()))

def GMI():
    return map(lambda x: int(x) - 1, input().split())

def LGMI():
    return list(map(lambda x: int(x) - 1, input().split()))

def solve():
    n=II()
    a=I()
    b=a
    for x,y in zip(a,b):
        print(x,end="")
        print(y,end="")

if __name__ == '__main__':
    for _ in range(1):
        solve()

B.也直接模拟c的话记得开longlong

import random
import sys
import os
import math
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from io import BytesIO, IOBase
from copy import deepcopy
import threading
import bisect

BUFSIZE = 4096


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def I():
    return input()

def II():
    return int(input())

def MI():
    return map(int, input().split())

def LI():
    return list(input().split())

def LII():
    return list(map(int, input().split()))

def GMI():
    return map(lambda x: int(x) - 1, input().split())

def LGMI():
    return list(map(lambda x: int(x) - 1, input().split()))

def solve():
    a=LII()
    res=0

    for i in range(0,64):
        res+=pow(2,i)*a[i]
    print(res)

    



if __name__ == '__main__':
    for _ in range(1):
        solve()

C.把每个数字位置拿出来排个序即可

import random
import sys
import os
import math
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from io import BytesIO, IOBase
from copy import deepcopy
import threading
import bisect

BUFSIZE = 4096


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def I():
    return input()

def II():
    return int(input())

def MI():
    return map(int, input().split())

def LI():
    return list(input().split())

def LII():
    return list(map(int, input().split()))

def GMI():
    return map(lambda x: int(x) - 1, input().split())

def LGMI():
    return list(map(lambda x: int(x) - 1, input().split()))

def solve():
    n=II()
    p=[[] for _ in range(0,n+10)]
    a=LII()
    for i,x in enumerate(a):
        p[x].append(i+1)
    res=[]
    for i in range(1,n+1):
        p[i].sort()
        res.append([p[i][1],i])
    res.sort()
    for i in range(0,n):
        print(res[i][1],end=" ")
    


    



if __name__ == '__main__':
    for _ in range(1):
        solve()

D

很明显一个状态机dp

状态表示，前i个选项里的最大值，且当前状态是无毒或者有毒

如果有毒，只能从前面的无毒转移过来或者不选当前选项从前面有毒继续转移过来

如果无毒，可以从前面有毒或者无毒或者不选转移过来

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;

const int N = 5e5+10;
typedef pair<int, int> PII;
int n,m,k;
PII a[N];
long long f[N][3];
signed main(){
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    cin>>n;
    //f[0]代表当前有毒，[1]无毒
    for(int i=1;i<=n;i++){
        cin>>a[i].first>>a[i].second;
    }
    memset(f,-0x3f,sizeof(f));
    f[0][0]=0;
    f[0][1]=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i].first==0)
        {
            f[i][0]=f[i-1][0];
            f[i][1]=max({f[i-1][1]+a[i].second,f[i-1][1],f[i-1][0]+a[i].second});
        }
        else{
            f[i][1]=f[i-1][1];
            f[i][0]=max({f[i-1][0],f[i-1][1]+a[i].second});
        }
    }
    cout<<max(f[n][0],f[n][1])<<"\n";
}

E

拿两个set维护

第一个set维护最大的k个，第二个维护剩余数

每次把全部数的最大的k个通过st1和st2的最小值和最大值交换即可

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;

const int N = 5e5+10;
int n,m,k;
int a[N];
signed main(){
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    cin>>n>>k>>m;
    multiset<long long> st1,st2;
    long long res=0;
    for(int i=1;i<=n;i++){
        if(i<=k) st1.insert(0);
        else st2.insert(0);
    }
    while (m -- )
    {
        int x,y;cin>>x>>y;
        int z=a[x];
        if(st1.find(a[x])!=st1.end())
        {
            st1.erase(st1.lower_bound(a[x]));
            res-=a[x];
        }
        else
        {
            st2.erase(st2.lower_bound(a[x]));
        }
        a[x]=y;
        st1.insert(a[x]);
        res+=a[x];
        while(st1.size()>k)
        {
            auto it=*st1.begin();
            st2.insert(it);
            st1.erase(st1.begin());
            res-=it;
        }
        while(st1.size()&&st2.size()&&*st1.begin()<*st2.rbegin())
        {
            auto a=*st1.begin(),b=*st2.rbegin();
            res+=b-a;
            st2.insert(a);st2.erase(st2.lower_bound(b));
            st1.insert(b);st1.erase(st1.lower_bound(a));
        }
        cout<<res<<"\n";
    }
}

F.离散化+树状数组

首先先别想那么多，对于第一个集合的第一个数他的所有贡献是啥呢

贡献就是下面全部集合比他小的值的全部个数

所以要有个数据结构可以边添加边询问前缀的总和（树状数组或者线段树）

从最后一个集合遍历即可，边加贡献边添加数

到这里还没结束，因为还没算自己集合的，自己集合前面比自己小的数也要算贡献

第i个集合下面有（n-i）个集合要和他匹配，且前面有j个比自己小，别忘了这个贡献

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;

const int N = 1e4+10,M=110,H=1e6+10;
typedef pair<int, int> PII;
int n,m,k;
int a[N][M];
vector<int> num;
int tr[H];
int lowbit(int x)
{
    return x & -x;
}

void add(int x, int c)  // 位置x加c
{
    for (int i = x; i <=num.size(); i += lowbit(i)) tr[i] += c;
}

int sum(int x)  // 返回前x个数的和
{
    int res = 0;
    for (int i = x; i; i -= lowbit(i)) res += tr[i];
    return res;
}

int find(int x){
    return lower_bound(num.begin(),num.end(),x)-num.begin()+1;
}
signed main(){
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)
            {
                cin>>a[i][j];
                num.push_back(a[i][j]);
            }
    }
    sort(num.begin(),num.end());
    num.erase(unique(num.begin(),num.end()),num.end());
    long long res=0;
    for(int i=n;i>=1;i--)
    {
        for(int j=1;j<=m;j++)
        {
            int x=find(a[i][j]);
            res+=sum(x);
            res+=(n-i)*j;
        }
        for(int j=1;j<=m;j++){
            add(find(a[i][j]),1);
        }
       
    }
    cout<<res<<"\n";
}

南岸以南南岸哀
关注
Atcoder Beginner Contest 306
m0_74087709的博客
06-19 257
long long范围在[-2^31,2^31-1]，存不下2^63次。
Atcoder Beginner Contest 306 A~E题解
璃儿安心
06-17 411
Atcoder Beginner Contest 306 A~E题解
AtCoder Beginner Contest 359
qq_58297895的博客
06-23 1549
这场我赛时打的非常不好，只做出了2题。
Atcoder Beginner Contest 350
djhws144的博客
04-25 1980
ABC350
AtCoder Beginner Contest 368
2301_78527293的博客
08-27 904
A - G
AtCoder Beginner Contest 365
congyuyoudao的博客
08-04 1037
对于B的顺序,我们无法直接通过贪心来得到我们需要的答案,因为我们可以可以通过故意平手来达到控制我们出手顺序的结果.对于这个题目,我们可以发现无后效性,对于当前出什么,只受到前面一个出手的影响.对于补贴可以无限大的情况,当且只有数组的总和小于等于M才行。对于这一次出什么,我们把两种情况(平手或者胜利)都考虑了.因为我们需要找到x的最大值,直接通过二分查找X即可.直接用sort排序以后输出第二大的数的下标即可。给你一个年份,判断当前年份有多少天。A与B进行猜拳,已知A的出手顺序.给你一个数组,找到第二大的数。
AtCoder Beginner Contest 360
2302_79454804的博客
07-01 415
找出在时间（T+0.1）之前，蚂蚁i和j（1≤i
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 854
AtCoder Beginner Contest 363 ABCDE
AtCoder Beginner Contest 369 题解
nike0good |Oier&ACMer | 熟能生巧
09-01 1173
A - 369 #include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n) for(int i=k;i<=n;i++) #define ForkD(i,k,n) for(int i=n;i>=k;i--) #define Rep(i,n) for(int i=0;i<n;i++) #define ForD(i,n) for(
【解题总结】Atcoder Beginner Contest 汇总
zqy1018的blog
09-14 926
ABC
AtCoder Beginner Contest 239
Z_Y_S_的博客
02-20 756
G 就是个最小割板子，但是打比赛时一直以为求最小割方案就是把流满的边当作割边，机房里几个人还同时犯了这个错误，错误的点的数量一样，当时一致认为数据有问题，事实上需要从源点开始跑广搜，找出源点不经过流量为000的边所能到达的所有的点记为SSS集，其余点记为TTT集，如果有一条边上的两个点所在集合不一样，那这条边就是割边 F 关键是怎么设状态，一开始设f(x)f(x)f(x)表示当前数为xxx，期望经过几次操作大于mmm，怎么推都只能推出一个暴力dpdpdp，事实上如果把状态设为f(x)f(x)f(x)表示从1
AtCoder Beginner Contest 229
Code_Shark的博客
12-06 384
AtCoder Beginner Contest 229 A. On and Off 题目描述 ​ 给你一个2×22\times 22×2的矩阵，由字符 ... ，#组成 问你能否从任意一个#不经过 ... 走到任意一个# 分析 ​ 也就是让我们判断是否联通 我们可以记录下来每个#的位置，然后如果连通，那么对于每个#必然有一个其他的#与他相邻 代码 #include<bits/stdc++.h> using namespace std; int main() { ios::sync
AtCoder Beginner Contest 285解题报告
m0_73935863的博客
01-16 810
AtCoder Beginner Contest 285解题报告
AtCoder Beginner Contest 206
m0_49959202的博客
06-30 375
文章目录AtCoder Beginner Contest 206A - Maxi-BuyingB - SavingsC - SwappableD - KAIBUNsyoE - Divide BothF - Interval Game 2 AtCoder Beginner Contest 206 A - Maxi-Buying 题意： 题解： 代码： #include <bits/stdc++.h> #define int long long #define debug(x) cout <
智能化运维的未来：AI和机器学习在运维中的应用
Echo_Wish的博客
11-05 480
AI和机器学习在运维中的应用，不仅提高了运维效率和质量，还为企业的数字化转型提供了强有力的技术支持。通过预测性维护、自动化运维、异常检测和智能告警等应用，企业可以更好地管理和优化其IT基础设施，确保系统的高效、稳定运行。希望本文能为读者提供有价值的参考，帮助你在运维实践中更好地应用AI和机器学习技术。如果有任何问题或需要进一步讨论，欢迎交流探讨。让我们共同推动智能运维的发展，实现更高效、更智能的运维管理。
【anaconda】使用记录
zhuyan108的博客
11-05 332
window11 下安装anaconda。
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1484
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【python GUI编码入门-21】如何用Tkinter创建一个记事本应用
最新发布
木头大左的博客
11-08 28
在现代编程环境中，图形用户界面（GUI）应用程序的开发变得越来越重要。Python的Tkinter库是一个功能强大且易于使用的GUI工具包，非常适合初学者和有经验的开发者使用。本文将详细介绍如何使用Tkinter创建一个简易的记事本应用，涵盖从安装到实现各项功能的全过程。Tkinter是Python的标准GUI库，它提供了丰富的接口来创建窗口、对话框、按钮等常见的GUI组件。Tkinter具有良好的跨平台性，可以在Windows、Mac OS和Linux上运行。
一次薅国家超算平台的记录
weixin_55179972的博客
11-07 407
参与 谁是下一个“AI”跃人 -AI体验推介活动，赢取千元算力券！（https://www.scnet.cn/home/subject/modular/index270.html）2. Clone开源的Llama3 Chinese （https://github.com/LlamaFamily/Llama-Chinese）活动名称主题：国家超算互联网「AI跃升季」：谁是下一个“AI”跃人 - AI算力体验活动。其中位置1，2替换为商品基模型和训练出来的微调模型。模型改为商城下载的模型。2、运行的过程记录。
atcoder beginner contest 265
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值