codeforces round 820 A~F

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量458 收藏
点赞数
分类专栏： Codeforces题解 文章标签： java c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729237/article/details/127133050
版权

文章目录

A

水题

import java.io.*;
import java.util.*;

public class Main {
    static FastScanner fs;
    public static void main(String[] args) {
        fs=new FastScanner();
        int t=fs.nextInt();
        for( int i =0;i<t;i++){
            System.out.printf("%d\n",solve());
        }


    }
    public static int solve(){
        int a,b,c;
        a=fs.nextInt();
        b=fs.nextInt();
        c=fs.nextInt();
        if(a-1<Math.abs(b-c)+c-1){
            return 1;
        }
        else if(a-1>Math.abs(b-c)+c-1){
            return 2;
        }
        else {
            return 3;
        }
    }


    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

B

从后向前遍历，遇到0则为两位数，否则为一位数

import java.io.*;
import java.util.*;

public class Main {
    static FastScanner fs;
    public static void main(String[] args) {
        fs=new FastScanner();
        int t=fs.nextInt();
        for( int i =0;i<t;i++){
            solve();
        }


    }
    public static void solve(){
        int n=fs.nextInt();
//        String s=fs.nextLine();
        StringBuffer s=new StringBuffer(fs.nextLine());
        StringBuffer res=new StringBuffer();
        for( int i=s.length()-1;i>=0;i--){
            if(s.charAt(i)=='0'){
                int x=Integer.parseInt(s.substring(i-2,i));
                res.append((char)(x+96));
                i-=2;
            }
            else{
                int x=Integer.parseInt(s.substring(i,i+1));
                res.append((char)(x+96));
            }
        }
        System.out.println(res.reverse());
    }


    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

C

使用二维变长数组，按照字母分类，将每个字母出现的位置存起来。

import java.io.*;

import java.util.*;

public class Main {
    static FastScanner fs;
    public static void main(String[] args) {
        fs=new FastScanner();
        int t=fs.nextInt();
        for( int i =0;i<t;i++){
            solve();
        }
    }
    public static void solve(){
        String s=fs.nextLine();
        int n=s.length();
        Vector<Integer>[]v=new Vector[26];
        for( int i=0;i<26;i++){
            v[i]=new Vector<Integer>();
        }
        for( int i=0;i<s.length();i++){
            v[s.charAt(i)-97].add(i);
        }
        Vector<Integer>res=new Vector<Integer>();
        int ans=Math.abs(s.charAt(0)-s.charAt(n-1));
        if(s.charAt(0)<=s.charAt(n-1)){

            for( int i=s.charAt(0);i<=s.charAt(n-1);i++){
                for (int it:v[i-97]) {
                    res.add(it);
                }
            }
        }
        else{
            for( int i=s.charAt(0);i>=s.charAt(n-1);i--){
                for (int it:v[i-97]) {
                    res.add(it);
                }
            }
        }
        System.out.print(ans+" "+res.size());
        System.out.println();
        for( int i=0;i<res.size();i++){
            System.out.print((res.elementAt(i)+1)+" ");
        }
        System.out.println();
    }


    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

D

贪心算法
先将两个数列做差，变为一个数列。
每个正数优先和一个负数配对，如果不能和负数配对，就和正数配对。
最后输出配对的组数。

import java.io.*;

import java.lang.reflect.Array;
import java.util.*;

public class Main {
    static FastScanner fs;
    public static void main(String[] args) {
        fs=new FastScanner();
        int t=fs.nextInt();
        for( int i =0;i<t;i++){
            solve();
        }
    }
    public static void solve(){
        int n=fs.nextInt();
        int []v=new int [n];
        for( int i=0;i<n;i++){
            v[i]=fs.nextInt();
        }
        for( int i=0;i<n;i++){
            int x=fs.nextInt();
            v[i]=x-v[i];
        }
//        Arrays.sort(v);
        ArrayList<Integer>pos=new ArrayList<Integer>();
        ArrayList<Integer>neg=new ArrayList<Integer>();
        for( int i=0;i<n;i++){
            if(v[i]>=0) pos.add(v[i]);
            else neg.add(v[i]);
        }
        Collections.sort(pos);
        Collections.sort(neg);
        int p=0;
        int ans=0;
        for( int i=pos.size()-1;i>=0;i--){
            while(p<neg.size()&&neg.get(p)+pos.get(i)<0) p++;
            if(p<neg.size()){
                ans++;
                p++;
            }
            else{
                if(i!=0){
                    i--;
                    ans++;
                }
                else break;
            }
        }
        System.out.println(ans);


    }


    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

E

对于询问（x,y）和（y,x）返回有50%不同，如果返回不同，则答案就是两个返回值相加。

import java.util.Scanner;

public class Main {
    static Scanner sc;
    public static void main(String[] args) {
        sc=new Scanner(System.in);

        long []rem=new long[25];
        long ans=0;
        for( int i=0;i<25;i++){
            rem[i]=query(1,i+2);
        }
        for( int i=0;i<25;i++){
            if(rem[i]<0){
                ans=i+1;
                break;
            }
            long temp=query(i+2,1);
            if(temp!=rem[i]){
                ans=Math.max(rem[i]+temp,ans);
            }
        }
        
        System.out.println("! "+ans);
    }
    public static long query( int x,int y){
        System.out.println("? "+x+" "+y);
        System.out.flush();
        long res=Long.parseLong( sc.nextLine());
        return res;
    }

}

F

利用前缀和的方法快速计算区间的值。

import javax.xml.stream.FactoryConfigurationError;
import java.io.*;
import java.util.*;

public class Main {
    static FastScanner sc=new FastScanner();
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static int []fac;
    static final int N=200100;
    public static void main(String[] args) {
        fac=new int[N];
        fac[0]=1;
        for( int i=1;i<N;i++){
            fac[i]=fac[i-1]*10%9;
        }
        sc=new FastScanner();
        int t=sc.nextInt();
        for( int i=0;i<t;i++){
            solve();
        }
    }
    static void solve(){
        String s=sc.next();
        int w,m;
        w=sc.nextInt();
        m=sc.nextInt();
        int cur=0;
        int prev[]=new int[s.length()];
        prev[0]=(s.charAt(0)-'0')%9;
        for( int i=1;i<s.length();i++){
            prev[i]=(prev[i-1]*10+(s.charAt(i)-'0'))%9;
        }
        Vector<Vector<Integer>>v=new Vector<Vector<Integer>>();
        for( int i=0;i<9;i++){
            v.add(new Vector<Integer>());
        }
        for( int i=0;i+w-1<s.length();i++){
            int x=(prev[i+w-1]+9-(i==0?0:prev[i-1])*fac[w-1]%9)%9;
            v.get(x).add(i);
        }
        for( int i=0;i<9;i++){
            Collections.sort(v.elementAt(i));
        }
        for( int i=0;i<m;i++){

            int l,r,k;

            l=sc.nextInt();
            r=sc.nextInt();
            k=sc.nextInt();
            --l;--r;
            int x=(prev[r]+9-(l==0?0:prev[l-1])*fac[r-l]%9)%9;
            int l1=s.length()+1,l2=s.length()+1;
//            for( int j=0;j<9;j++){
//
//                System.out.println(v.elementAt(j).elementAt(0));
//            }
//            System.out.println(x);
            for( int j=0;j<9;j++){
                for( int p=0;p<9;p++){
                    if((j*x+p)%9!=k) continue ;
                    if(j!=p){
                        if(v.elementAt(j).size()==0||v.elementAt(p).size()==0) continue;
                        else {
                            int y=v.elementAt(j).elementAt(0)+1;
                            int z=v.elementAt(p).elementAt(0)+1;
                            if(y<l1){
                                l1=y;
                                l2=z;
                            }
                            else if(y==l1){
                                l2=Math.min(l2,z);
                            }
                        }
                    }
                    else {
                        if(v.elementAt(j).size()<2) continue;
                        else {
                            int y=v.elementAt(j).elementAt(0)+1;
                            int z=v.elementAt(p).elementAt(1)+1;
                            if(y<l1){
                                l1=y;
                                l2=z;
                            }
                            else if(y==l1){
                                l2=Math.min(l2,z);
                            }
                        }
                    }

                }
            }


            if(l1>s.length()) {
                out.printf("%d %d\n",-1,-1);
            }
            else{
                out.printf("%d %d\n",l1,l2);

            }
            out.flush();

        }



    }

    static class FastScanner
    {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String next()
        {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {

            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException
        {
            return br.readLine();
        }
    }
}
_zpf
关注
专栏目录
Codeforces Round 918 A~F题
zoloftkiller的博客
02-13 1987
【代码】Codeforces Round 918 A~F题。
Educational Codeforces Round 110 A~E
CarolusRex的博客
06-06 1028
Educational Codeforces Round 110 A~E by CarolusRex contentA. Fair PlayoffB. Array ReoderingC. Unstable StringD. Playoff TournamentE. Gold Transfercode A. Fair Playoff 点点点 B. Array Reodering 点点点 C. Unstable String 题意： T(1⩽T⩽104)T\left(1\leqslant T\leqslant
Codeforces Global Round 26 A~E
Code_Shark的博客
06-16 1294
将非空数组的范围定义为最大值减去最小值。例如，142的范围是4−13。给你一个长度为n≥3的数组a1​a2​an​。a。你必须给a如果不存在这样的着色，则输出NO。如果存在多种有效着色，则可以输出其中任何一种。
Codeforces Round #726 A~F
CarolusRex的博客
06-20 3964
by。
Codeforces Round 975 (Div. 2)(A~F)
weixin_61825750的博客
09-28 2283
疯狂掉分中
Educational Codeforces Round 135 A~D （构造、优先队列、区间DP）
zy98zy998的博客
09-09 396
Educational Codeforces Round 135 (Rated for Div. 2) A~D
Codeforces Round 900 (Div. 3) A~F
m0_63410759的博客
09-27 643
【代码】Codeforces Round 900 (Div. 3) A~F。
Codeforces Round 903 (Div. 3)A~F
weixin_62701031的博客
10-14 768
题意:字符串s每次操作后变成s+s，问能否操作若干次是t是s的字串。思路：数据范围很小，len(s)和len(t)最大25，要么如果枚举到len(s)长度大于等于len(t)的二倍，还没有出现答案，之后就不会出现答案。故需要枚举log2(50)上取整次，即六次。
Codeforces Round 966 (Div. 3) （A~F）
wh233z的博客
08-15 1600
赛时写的还挺快的，50分钟就A了4道题，当时排名已经到2千多了，后面就坐牢1个多小时······，E题一开始想用贪心先把猴子放在网格图的中间，后面觉得实现起来太麻烦了，直接做F题了，赛时也是用的贪心，没过，赛后想了想应该用DP的，本质上就是背包问题，当时没想到这点，DP学了还是不会用，题型还是见太少了····
Codeforces Round 953 (Div. 2) （A~F）（冒充Div2）
weixin_61825750的博客
06-16 1645
思路：很经典的将区间操作转化成端点操作，首先考虑全部修改，然后可以发现对比于区间修改而言，只有区间最靠左的两个数跟区间最靠右的两个数可能会不一样，因此只需要关注区间的左右四个点即可，若区间长度小于4的我们直接特判。思路：分类讨论，首先若后面的选举人存在比当前选举人票数多的情况，那么必然是将前面所有的人全部排除，然后再看票数是否大于后面最大的票，若还是小，则将后面票数最多的人也排除掉。的图,所有的斜率为-1的线上所有的顶点全部连通（1除外，需要特判）。总上，我们需要统计的是，删去前。个人的票小于他的最小。
Codeforces Round #780 (Div. 3) A ~ F2
m0_62325831的博客
04-01 826
A. Vasya and Coins 题意： 给定 aaa 个一元硬币和 bbb 个二元硬币，求最小不能支付的金额。 思路： 若 a>0a > 0a>0，则可以支付出所有不大于 a+2∗ba + 2 * ba+2∗b 的金额；否则，无法支付出 111 的金额。 代码： void solve() { ll a, b; cin >> a >> b; if(!a) { cout << "1\n"; ret
[题解][Codeforces 1137A~1137F]Codeforces Round #545 (Div. 1) 简要题解
女装的你，如此好看！
04-01 560
第一次打 Div. 1 ，感觉题目质量还是比较好的 然后就把我这个菜鸡选手区分到了榜末 题目 洛谷 RemoteJudge A B C D E F Codeforces A B C D E F A 题意 一个 n×mn\times mn×m 矩阵 aaa 定义 f(x,y)f(x,y)f(x,y) 表示在矩阵中取出第 xxx 行和第 yyy 列 设一个新矩阵 bbb ，这个矩阵只有第...
Educational Codeforces Round 114 (Rated for Div. 2) （A ~ F）全题解
繁凡さん的博客
09-21 976
A ~ F 前四题过于简单（） 后两题有点要命（）
[题解][Codeforces 1139A~1139F]Codeforces Round #548 (Div. 2) 简要题解
女装的你，如此好看！
03-26 1330
终于 rank < 10 了 题目 洛谷 RemoteJudge A B C D E F Codeforces A B C D E F A 题意 一个长度为 nnn 的数字串 sss 求 sss 有多少个子串，满足子串内的数字顺次连接后得到的数是偶数 1≤n≤650001\le n\le 650001≤n≤65000 且 sss 不包含 000 题解 ∑i=1ni[s[i]...
Codeforces Round #701 (Div. 2) A ~ F ，6题全，超高质量良心题解【每日亿题】2021/2/13
繁凡さん的博客
02-13 2756
Codeforces Round #701 (Div. 2) A ~ F ，6题全，超高质量良心题解【每日亿题】2021/2/13
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 382
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 898
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 948
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 470
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
codeforces round 887
08-23
Codeforces Round 887是一个程序设计竞赛活动，由Codeforces组织举办。根据引用中的代码，该竞赛的题目要求解决一个序列操作的问题。给定一个长度为n的序列，通过执行一系列操作，使得序列变得非sorted，即非严格...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值