说在前面

我把这段时间刷的题也也整理成了一个小专栏：

关于这次蓝桥杯，比赛的时候没有看D题，G和H花了好长时间，呜呜....，等比赛结束的时候边走边看题才知道是送分题，考后相当于是补题了，好遗憾，痛失10分，也许人生就是这样，十之八九是遗憾，但这又有何妨呢，前方康庄大道，还有很多美好的事情等着我呢！！！

下面就把这次我看过的并且感觉能做的题目写一下吧，如有错误，欢迎评论区指正！！

试题 A: 阶乘求和

【问题描述】 令 S = 1! + 2! + 3! + ... + 202320232023! ，求 S 的末尾 9 位数字。 提示：答案首位不为 0 。 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

代码：

/**
 * @author yx
 * @date 2023-04-08 9:11
 */
public class t1 {
    public static void main(String[] args) {
//        420940313
        long ans=0;
        long temp=1000000000;
        long temp1=1;
        for (long i = 1; i <= 202320232023L ; i++) {
            temp1=((temp1%temp)*(i%temp))%temp;
            ans=(ans%temp+temp1%temp)%temp;
            System.out.println("temp1是："+temp1+"  ans是："+ans+"   i是："+i);
        }
//        System.out.println("答案是："+ans);
    }
}

题目分析：

答案是：420940313 这道题目最后给的是202320232023的阶乘，这玩意要是用电脑暴力解，估计要很长时间（我一开始也是无脑暴力，但是感觉要好久） 这题完全不需要开到202320232023，因为从39！开始，后面阶乘和的末尾9位数字就不发生改变了

试题 B: 幸运数字

试题 B: 幸运数字 本题总分： 5 分 【问题描述】 哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整 数。例如 126 是十进制下的一个哈沙德数，因为 (126) 10 mod (1+2+6) = 0 ； 126 也是八进制下的哈沙德数，因为 (126) 10 = (176) 8 ， (126) 10 mod (1 + 7 + 6) = 0 ； 同时 126 也是 16 进制下的哈沙德数，因为 (126) 10 = (7 e ) 16 ， (126) 10 mod (7 + e ) = 0 。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为 哈沙德数，那么这个数字就是幸运数字，第 1 至第 10 个幸运数字的十进制表示 为： 1 , 2 , 4 , 6 , 8 , 40 , 48 , 72 , 120 , 126 . . . 。现在他想知道第 2023 个幸运数 字是多少？你只需要告诉小蓝这个整数的十进制表示即可。 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

代码：

import java.awt.*;

/**
 * @author yx
 * @date 2023-04-08 9:13
 */
public class t2 {
    public static void main(String[] args) {
        int ans=0;
        int i=0;
        while (true){
            i++;
            if(isCheck(i)){
                ans++;
                System.out.println(i+"为第"+ans+"个");
            }
            if(ans==2023){
                break;
            }
        }
        System.out.println("答案是："+i);
    }
    static boolean isCheck(int n){
        String temp1=Integer.toString(n,2);
        String temp2=Integer.toString(n,8);
        String temp3=n+"";
        String temp4=Integer.toString(n,16);
        int temp_1=0;
        int temp_2=0;
        int temp_3=0;
        int temp_4=0;
        for (int i = 0; i < temp1.length(); i++) {
            temp_1+=Integer.parseInt(temp1.substring(i,i+1));
        }
        if(n%temp_1!=0){
            return false;
        }
        for (int i = 0; i < temp2.length() ;i++) {
            temp_2+=Integer.parseInt(temp2.substring(i,i+1));
        }
        if(n%temp_2!=0){
            return false;
        }
        for (int i = 0; i < temp3.length(); i++) {
            temp_3+=Integer.parseInt(temp3.substring(i,i+1));
        }
        if(n%temp_3!=0){
            return false;
        }
        for (int i = 0; i < temp4.length(); i++) {
            if((temp4.substring(i,i+1)).toCharArray()[0]>=a){
                temp_4 += (temp4.substring(i,i+1)).toCharArray()[0]-a+10;
            }else {
                temp_4 += Integer.parseInt(temp4.substring(i, i + 1));
            }
        }
        if(n%temp_4!=0){
            return false;
        }
        return true;
    }
}

题目分析：

答案是：215040 直接把数先进制转换，然后求数位和，判读能否整除数位和就好了 这题本质考一个进制转换，如果会用Java的API就很简单,前两天我在算法组会分享的时候刚好讲过，还写了题解，还上了热榜，哈哈哈，下面链接的第五题

import java.io.*;

/**
 * @author yx
 * @date 2023-04-08 13:57
 */
public class D {
    static PrintWriter out =new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        String[] sp=ins.readLine().split(" ");
        int x1=Integer.parseInt(sp[0]);
        int y1=Integer.parseInt(sp[1]);
        int x2=Integer.parseInt(sp[2]);
        int y2=Integer.parseInt(sp[3]);
        int x3=Integer.parseInt(sp[4]);
        int y3=Integer.parseInt(sp[5]);
        int x4=Integer.parseInt(sp[6]);
        int y4=Integer.parseInt(sp[7]);
        long ans=0;
        int max_X=Math.max(Math.max(x1,x2),Math.max(x3,x4));
        int max_Y=Math.max(Math.max(y1,y2),Math.max(y3,y4));
        int max=Math.max(max_X,max_Y);
        int[][] Map=new int[max+1][max+1];
        for (int i = y1; i <= y2-1 ; i++) {
            for (int j = x1; j <= x2-1 ; j++) {
                Map[i][j]+=1;
            }
        }
        for (int i = y3; i <= y4-1 ; i++) {
            for (int j = x3; j <= x4-1 ; j++) {
                Map[i][j]+=1;
            }
        }
        for (int i = 0; i <= max_X ; i++) {
            for (int j = 0; j <= max_Y ; j++) {
//                System.out.print(Map[j][i]+" ");
                if(Map[j][i]>=1){
                    ans++;
                }
            }
//            System.out.println();
        }
        System.out.println(ans);
    }
}

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;

/**
 * @author yx
 * @date 2023-04-08 11:31
 */
public class G3 {
    static PrintWriter out = new PrintWriter(System.out);
    static BufferedReader ins = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in = new StreamTokenizer(ins);

    public static void main(String[] args) throws IOException {
        String s = ins.readLine();
        int N = Integer.parseInt(s);
        String[] sp = ins.readLine().split(" ");
        ArrayList<Integer> list = new ArrayList<>();
        long ans = 0;
        for (int i = 0; i < N; i++) {
            list.add(Integer.parseInt(sp[i]));
        }
        Collections.sort(list);
        for (int i = 0; list.size()>0 ; i++) {
            int a1 = 0;
            int a2 = 0;
            a1 = list.get(list.size()  - 1);
            list.remove(list.size()  - 1);
            if(list.size() - 1>=0) {
                a2 = list.get(list.size()  - 1);
                list.remove(list.size()  - 1);
                int mid = a2 / 2;
                int length=list.size();
                for (int j = length-1; j >= 0; j--) {
                    if (list.get(j) <= mid) {
                        list.remove(j);
                        break;
                    }
                }
            }
            ans += (a1 + a2);
        }
        out.println(ans);
        out.flush();
    }
}

代码：

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @author yx
 * @date 2023-04-08 12:04
 */
public class H1 {
    static class Node implements Comparable<Node>{
        int count;
        int color;

        Node(int count, int color) {
            this.count = count;
            this.color = color;
        }

        @Override
        public int compareTo(Node o) {
            if(this.color==o.color){
                return this.count-o.count;
            }else {
                return 0;
            }
        }
    }

    static PrintWriter out = new PrintWriter(System.out);
    static BufferedReader ins = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in = new StreamTokenizer(ins);

    public static void main(String[] args) throws IOException {
        String s = ins.readLine();
        int n = Integer.parseInt(s);
        String[] strings1 = ins.readLine().split(" ");
        String[] strings2 = ins.readLine().split(" ");
        Node[] nodes = new Node[n];
        int count = 0;
        int color = 0;
        long ans=0;
        ArrayList<Node>list=new ArrayList<>();
        for (int i = 0; i < n; i++) {
            count = Integer.parseInt(strings1[i]);
            color = Integer.parseInt(strings2[i]);
            Node node = new Node(count, color);
            list.add(node);
        }
        Collections.sort(list);
//        for (int i = 0; i < n; i++) {
//            System.out.println(list.get(i).count);
//        }
//        System.out.println(list.size());
        int length=list.size();
        for (int j = 0; j < length; j++) {
            for (int i = 1; i < list.size(); i++) {
                if (list.get(i).color == list.get(i - 1).color) {
                    Node node1 = list.get(i);
                    Node node2 = list.get(i - 1);
                    Node node3 = new Node(0, 0);
                    if (node1.color == 0) {
                        node3 = new Node(node1.count + node2.count, 1);
                    } else if (node1.color == 1) {
                        node3 = new Node(node1.count + node2.count, 2);
                    } else {
                        node3 = new Node(node1.count + node2.count, 0);
                    }
                    list.get(i-1).count = node3.count;
                    list.get(i-1).color = node3.color;
                    ans += node3.count;
                    list.remove(i);
//                    i--;
                }
            }
        }
        out.println(list.size()+" "+ans);
        out.flush();
    }
}

题目思路：

分堆问题，前两天刚做过，简单的分堆问题可以用优先队列，前天写的题解第四题合并果子但是很显然这题是加强版分堆问题，具体体现如下： 只有同一类的堆才能合并 堆合并之后会进化(堆号为0合并后--->堆号变为1........) 这题我用局部优先队列的思想，用ArrayList实现，自定义一个Node，然后重写排序，局部堆号相同的按堆数count递增排序（count小的先合，并保证count数大的堆重复合并次数最少） 从头节点开始往下遍历，判断下一个堆是否能合并，如果能合并，更新当前节点，删除下一个节点,ans+=当前节点的count+下一个节点的count 最后list的节点个数就是最小堆数

说在最后

趁着刚比完赛，思路还是比价清晰的，终于写完了题解，相比去年我感觉自己面对算法变得更加从容了一些(虽然还是算法小菜鸡)，这段时间因为要备战考研，所以每天也就只能在上课的时候练算法题，考研之余写写算法有时会放松心情有时会增加焦虑，不管怎样，这一个月都坚持下来了，接下来就是安心备战考研啦，可能会很长一段时间不更文，各位uu尽情谅解⏲️

最后希望正在看这篇文章的uu，蓝桥都能取得好成绩！！！

蓝桥杯，咱们有缘江湖再见呀！