第十三届蓝桥杯省赛JavaA组解析

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量757 收藏 17
点赞数 2
文章标签： java 算法 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MuZiChunChun/article/details/129985186
版权

public class Main{
    public static void main(String[] args){
        System.out.println(4+(20-1)+20*(22-1));
}

答案：443

 方法一：蛮力算法，注意Long.MAX_VALUE为：9223372036854775807，闲着没事干儿可以用这个方法，答案约等于2e15<9e18(Long的最大值)，可以循环出结果

public class Main {

    public static void main(String[] args) {
        long m=Long.MAX_VALUE;
        for(long i=0;i<m;i++) {
                if(
                        i%2==1&&
                        i%3==1&&
                        i%4==1&&
                        i%5==1&&
                        i%6==1&&
                        i%7==1&&
                        i%8==1&&
                        //此处省略
                        i%48==41&&
                        i%49==46
                        ) {
                    System.out.println(i);
                }else {
                    System.out.println("没有找到");
                }
        }
    }
}
 

方法二：利用步长逐步累加

public class Main{
    
    public static void main(String[] args) {   
        int[] a = {
                0, 0,//为了使a[i]与i匹配，这里放入0填充a[0],a[1]
                1, 2, 1, 4, 5, 4, 1, 2, 9, 0, 5, 10,
                11, 14, 9, 0, 11, 18, 9, 11, 11, 15, 17, 9,
                23, 20, 25, 16, 29, 27, 25, 11, 17, 4, 29, 22,
                37, 23, 9, 1, 11, 11, 33, 29, 15, 5, 41, 46
                };
        long begin = 1;//满足题给条件的第一个模2的情况，即模2等于1的情况
        long step = 1;
        for (int i = 2; i < a.length - 1; i++) {
            step = lcm(step, i);//每个步长本质就是前面i-1个数（除数）的最小公倍数
            while (begin% (i + 1) != a[i + 1]) {
                begin += step;//步长的作用就是为满足下一次模运算而逐步累加到目标值
            }
        }
        System.out.println(begin);
    }

    //求最大公约数,不用考虑a，b的大小关系，可以自动调整
    private static long gcd(long a, long b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    //求最小公倍数
    private static long lcm(long a, long b) {
        return (a * b)/ gcd(a, b) ;
    }
}
答案：2022040920220409

import java.util.Scanner;

public class Mian {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n];
        for(int i=0;i<a.length;i++) {
            a[i]=sc.nextInt();
        }
        long s = 0;
        for(int i=0;i<a.length;i++) {
            for(int j=i+1;j<a.length;j++) {
                s+=a[i]*a[j];
            }
        }
        System.out.print(s);
    }

}

样例答案：117

 法一：

public class Main{

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt(),m;
        m=Math.abs(a-b);        /*假设m可被a+k，b+k整除，那么a%m=b%m,则(a-b)%m=0,要使得m最大，只需要令a-b的绝对值等于m即可。*/
        System.out.print((m-a%m)%m);        /*因为（a+k）%m=0，则a%m（或b%m）得到一个余数，而k值就是m-a%d，k值要保证最小，那么用k%m即可得到结果。*/
    }
}

法二：

令m=|a-b|，m就是a，b的最大公约数或者是最大公约数的最大倍数，即m确定了公约数的上限，m的大小位置有两个，一个是m在（a,b）之间，另一个是m比a和b都小。

第一种情况下，k值就是m-min（a，b）

第二种情况下，找到一个最小整数n，使得m*n>a，则k=m*n-a；或者找到一个最小整数n，使得m*n>b，则k=m*n-b

import java.util.*;
public class Main {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        long a,b;
        long m;
        a=in.nextLong();
        b=in.nextLong();
        m=Math.abs(a-b);
        long k=0;
        if(a==m||b==m) k=0;
        else if(m<=a&&m<=b) {
            long temp;
            long t;
           t=Math.max(a,b)/m+1;
           k=t*m-Math.max(a, b);
        }
        else {
            k=m-Math.min(a, b);
        }
        System.out.println(k);
    }
}

 参见：(12条消息) 第十三届蓝桥杯【蜂巢】最简单的解法_Wuxy1999的博客-CSDN博客

 

 import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
             Scanner sc = new Scanner(System.in);
             int n= sc.nextInt();
             long num=1;             
             long sum=1;
             long []dp=new long[n+1];
             dp[0]=0;
             dp[1]=0;
             for (int i = 2; i <=n ; i++) {
                 dp[i]=(dp[i-1]*(i)+num*sum)%998244353;
                 sum=(sum+i)%998244353;
                 num=(num*i)%998244353;
             }
             System.out.println(dp[n]);
    }
}

此处用到动态规划，数值n的全排列的价值可分为两部分，一部分是dp[n-1]*n，另外一部分是（n-1）!*(1+2+...+n-1)。

第一部分，dp[n-1]的价值假定已经确定，那么插入第n个数字的时候，每一个原排列会新产生n个新排列，那么全部新排列的价值就是dp[n-1]*n。例如，dp[4-1]的价值已经确定是9，那么插入第4个数字（也就是4），第一个原排列123会产生4123,1423,1243,1234四个新排列，而原排列一共有3！个，那么新的排列总共就有24个，但这24个排列在不考虑数字4引起的价值变化的前提下，全排列价值仅发生倍数变化，就是dp[3]*4，价值变化的原因也仅仅是排列数量的增多而已。

第二部分，我们的第一部分已经考虑了插入第n个数字后，排列增多引起的价值变化，但我们没有考虑第n个数字引起的价值变化。n-1个数字的排列有(n-1)!个，而对于每个排列，排列的间隔不会改变，数字n的插入位置有n种选择，插入数字n后，n的前面有几个数字，那么这个排列因为n的价值就是几（n在这个排列里面最大）。例如排列123，插入4，就有4123,1423,1243,1234，价值分别为0,1,2,3。所以，插入n引起的价值变化有（n-1）!*(1+2+...+n-1)。

 

法一：此方法思路简单，但已经超时

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        long x=0;
        int n;
        Scanner s=new Scanner(System.in);
        n=s.nextInt();
        for(int i=1;i<n+1;i++) {
            x+=f(i);
        }
        System.out.print(x%(1e9+7));
    }
    private static long f(long x) {
        long a=0;
        for(long i=1;i<x+1;i++) {
            if(x%i==0)a+=i*i;
        }
        return a;        
    }
}

法二：仅适用问题规模较小时，摘自https://blog.csdn.net/qq_46311811/article/details/124067689

import java.util.Scanner;

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

        long[] arr = new long[n + 1];
        long sum = 0;
        for (long i = 1; i < arr.length; i++) {
            long j = i;
            while (j < arr.length) {
                arr[(int) j] = (arr[(int) j] + i * i) % 1000000007;
                j += i;
            }
            sum = (sum + arr[(int) i]) % 1000000007;
        }

        System.out.println(sum);
    }
}
法三：最优算法，摘自https://blog.csdn.net/feng8403000/article/details/128891276

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        final long N = 1000000007;
        final long inv6 = 166666668;
        Scanner sc = new Scanner(System.in);
        long res = 0, temp = 0, sum = 0;
        long n, l, r, k;
        n = sc.nextInt();
        sc.close();
        for (long i = 1; i <= n; i = r + 1) {
            l = i;
            k = n / i;
            r = n / (n / l);
            temp = sum;
            sum = r * (r + (long) 1) % N * ((long) 2 * r + 1) % N * inv6 % N;
            res = (res + k * (sum - temp) + N) % N;
        }
        System.out.println(res);
    }
}

 

import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n,k ;
        n = sc.nextInt();
        k = sc.nextInt();
        int a[]= new int[n];
        for(int i=0;i<a.length;i++) {
            a[i] = sc.nextInt();
        }
        //Arrays.sort(a);
        System.out.println(f(a,k));        
    }
    private static  long f(int b[], int k) {
        int count = 0;//用于计数    
        int location = 0;//用于标记在数组中的位置
        while(location <= b.length -k) {//按步长k移动到最后b.length%k时，可以退出循环
            long min = Integer.MAX_VALUE;
            int c = 0;
            for(int i=location ;i<location+k;i++){//在步长k内进行循环，找到最小值
                if(b[i] <= min) {
                    min = b[i];
                    c = i;//假定序列已经按升序进行排列
                }
            }
            for(int i=location;i<location+k;i++) {
                b[i]-=min;//这里的min就是连续k个数统一减小的次数
            }
            count+=min;
            location=c+1;//记录下一次起始位置
        }        
        for(int j=location;j<b.length;j++) {//此时只能一个数一次一次的减小
            count+=b[j];
        }
        return count;
    }    
}

摘录自2022年蓝桥杯省赛java A组考后总结_java蓝桥杯a组_Hydrion-Qlz的博客-CSDN博客

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class Main{
    static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in = new StreamTokenizer(bf);

    static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static void main(String[] args) throws IOException {
        int N = nextInt();
        int M = nextInt();
        int Q = nextInt();
        int[][] knowArr = new int[N][N];
        int[][] givenArr = new int[M][2];
        for (int i = 0; i < givenArr.length; i++) {
            int l = nextInt() - 1;
            int r = nextInt() - 1;
            int S = nextInt();
            knowArr[l][r] = S;
            // 以l为终点
            if (l > 0) {
                for (int j = 0; j < N && j < l; j++) {
                    if (knowArr[j][l - 1] != 0) {
                        knowArr[j][r] = knowArr[j][l - 1] + S;
                    }
                }
            }
            // 以l为起点
            if (l < N - 1) {
                for (int j = l + 1; j < N; j++) {
                    if (knowArr[l][j] != 0) {
                        if (j < r) {
                            knowArr[j + 1][r] = S - knowArr[l][j];
                        } else if (j > r) {
                            knowArr[r + 1][j] = knowArr[l][j] - S;
                        }
                    }
                }
            }
            // 以r为终点
            if (r > 0) {
                for (int j = 0; j < N && j < r; j++) {
                    if (knowArr[j][r] != 0) {
                        if (j < l) {
                            knowArr[j][l - 1] = knowArr[j][r] - S;
                        } else if (j > l) {
                            knowArr[l][j - 1] = S - knowArr[j][r];
                        }
                    }
                }
            }
            // 以r为起点
            if (r < N - 1) {
                for (int j = r + 1; j < N; j++) {
                    if (knowArr[r][j] != 0) {
                        knowArr[l][j] = S + knowArr[r][j];
                    }
                }
            }
        }

        for (int i = 0; i < Q; i++) {
            int l = nextInt() - 1;
            int r = nextInt() - 1;
            if (knowArr[l][r] != 0) {
                System.out.println(knowArr[l][r]);
            } else {
                System.out.println("UNKNOWN");
            }
        }
    }
}

 

PlumCarefree
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
第十三届蓝桥杯JavaA组省赛第二场
05-14
第十三届蓝桥杯JavaA组省赛第二场原题第十三届蓝桥杯JavaA组省赛第二场原题第十三届蓝桥杯JavaA组省赛第二场原题第十三届蓝桥杯JavaA组省赛第二场原题第十三届蓝桥杯JavaA组省赛第二场原题第十三届蓝桥杯JavaA组省赛...
2021年第十二届蓝桥杯javaA组国赛
衣点QIAO的博客
06-19 1300
文章目录试题 A: 纯质数试题 B: 完全日期试题 C: 最小权值试题 D: 覆盖试题 E: 123试题 F: 二进制问题试题 G: 冰山试题 H:: 和与乘积试题 I: 异或三角试题 J: 积木 以下均为个人想法和解题思路，如有错误或不足，欢迎指正。 试题 A: 纯质数 本题总分：5 分 【问题描述】 如果一个正整数只有 1 和它本身两个约数，则称为一个质数（又称素数）。 前几个质数是：2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, · · · 。 如果
2023第十四届蓝桥杯JavaA组真题题解，代码均通过测试平台测试
weixin_73936404的博客
09-05 1008
简单的暴力循环求解35813063。
第十三届蓝桥杯Java研究生组部分题解
SmallBoatC的博客
02-06 271
第十三届蓝桥杯Java研究生组部分题解
第十三届蓝桥杯大赛软件赛省赛（Java 大学A组）
热门推荐
NOW I GOT ONE WAY
04-11 3万+
第十三届蓝桥杯大赛软件赛省赛 Java 大学 A 组
蓝桥杯2023年第十四届省赛真题------第十四届蓝桥杯本科A组/研究生组2023年省赛题解--全部采用Java语言实现
[email protected]
04-21 3407
今天现在这里 挖个坑，太忙了，这个专题不一样有时间补完，但我会尽力而为的。记录一下今天的日子：2023/04/21看看这个坑要什么时候自己才能补完。的文章参考。
第十四届蓝桥杯大赛软件赛省赛（Java 大学A组）
NOW I GOT ONE WAY
05-08 5994
第十四届蓝桥杯大赛软件赛省赛 Java 大学 A 组
蓝桥杯java技巧总结
qq_41777702的博客
06-16 6324
蓝桥杯java基础
蓝桥杯算法考前复习要点和归纳总结
星辰大数据的博客
07-09 1万+
一、重要知识要点 1、穷举法 2、枚举法 3、动态规划 4、回溯法 5、图论 6、深度优先搜索（DFS） 7、广度优先搜索（BFS ） 8、二叉树 9、递归 10、分治法、矩阵法 11、排列组合 12、素数、质数、水仙花数 13、欧几里得定理gcd 14、求最大公约数、最小公倍数 15、海伦公式（求三角形面积） 16、博弈论 17、贪心...
【蓝桥杯】Java开发A组省赛真题+详细解析
丧心病狂Loli控的博客
04-19 1402
1. 世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。   还有人称今后的某个世纪末的12月31日，如果是星期一则会…   有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!   于是，“谣言制造商”又修改为星期日…   1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？   请回答该年份（只写这个4位整数，不要写12月31等多余
2023第十四届蓝桥杯JavaA组真题 试题D:棋盘
m0_62243101的博客
04-18 503
pre[i][j]表示i,j格上的棋子颜色改变的次数。如果为偶数次，则最终颜色未发生改变，仍为白色；如果为奇数次，则最终颜色发生改变，变为黑色。将x1,y1,x2,y2范围内的棋子颜色取反，可以考虑用差分操作实现O(1)的时间复杂度，暴力是O(n^2)的时间复杂度。由于棋子只有两种颜色，且初始均为白色。因此，我们可以定义一个二维前缀和数组。试题D如果用暴力思路是O(n^3)的时间复杂度，只能过30%的测试点。每次修改操作的时间复杂度为O(1)最终的时间复杂度为O(n^2)
2023第十四届蓝桥杯Java大学生A组真题？（真题+附链接）
m0_74939018的博客
04-19 544
其中 arr[0] = (In[0], In[1], In[2], In[3], In[4]) 表示的是输入数据，对于某 个 arr[i][ j](i ≤ 0)，计算方式为 arr[i][ j] = arr[i − 1][ j] op arr[i − 1][ j + 1]，其中 op 表示的是将 arr[i − 1][ j]、arr[i − 1][ j + 1] 作为输入，将 arr[i][ j] 作为输出的那个门电路，与门、或门、异或门分别对应于按位与 (&)、按位或 (|)、按位异或 (^) 运算符。
2017第八届蓝桥杯大赛个人赛省赛（软件类C/C++）真题（A/B/C）
03-10
2017第八届蓝桥杯大赛个人赛省赛（软件类）真题。ps：附带个人答案
2022年第十三届蓝桥杯大赛软件赛Java 大学A 组省赛第二场、决赛
06-21
2022年第十三届蓝桥杯大赛软件赛Java 大学A 组省赛第二场、决赛
2018第九届蓝桥杯省赛Java语言A组
04-02
2018第九届蓝桥杯省赛Java语言A组 全部10道题 祝大家取得好成绩！
2022年第十三届蓝桥杯各组真题
01-20
2022年第十三届蓝桥杯各组真题，包含C/C++A,B组，JavaA,B组，PythonA,B组，
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 956
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 897
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 819
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
蓝桥杯第十三JavaA
04-11
蓝桥杯是中国最大的IT技能竞赛之一，旨在培养和选拔优秀的计算机人才。蓝桥杯分为初赛和决赛两个阶段，其中初赛是在线考试形式，决赛则是线下实操比赛。 蓝桥杯第十三届JavaA组是指蓝桥杯竞赛中的Java语言组别A类别。该类别主要考察参赛选手在Java语言基础、面向对象编程、数据结构与算法等方面的知识和能力。 具体来说，蓝桥杯第十三JavaA的考试内容可能包括但不限于以下几个方面： 1. Java基础知识：包括数据类型、运算符、流程控制、数组、字符串等基本概念和语法。 2. 面向对象编程：包括类与对象、继承与多态、封装与继承等面向对象的基本概念和应用。 3. 数据结构与算法：包括线性表、栈与队列、树与图等数据结构的基本概念和常见算法的实现。 4. 输入输出与异常处理：包括文件读写、异常处理机制等相关知识。 5. Java标准库的使用：包括集合框架、IO流、多线程等Java标准库的常用类和方法的使用。 参加蓝桥杯第十三JavaA组的选手需要具备扎实的Java编程基础和良好的编程能力，同时需要具备一定的算法和数据结构的理解和应用能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值