2024睿抗机器人编程技能赛（JAVA）

2024睿抗机器人编程技能赛心得分享（JAVA）

博主主学JAVA，故参赛时，主要采取JAVA语言进行解题。完整题目和试做可以参考官方网站2024睿抗编程赛

题目一、热热热

热҈热҈热҈……最近热得打的字都出汗了！

幸好某连锁餐厅开启了气温大于等于 35 度即可获得一杯免费雪碧的活动。但不知为何，在每个星期四的时候，这个活动会暂停一天……

现在给定连续的若干天的气温情况以及给定的第一天是星期几，请你算出有多少天你可以喝到免费的雪碧，又有多少天是因为星期四而导致你喝不到雪碧的。

输入格式:
输入第一行是两个正整数 N, W (1≤N≤50,1≤W≤7)，表示给定连续的 N 天，下面给定的第一天是星期 W（7 等于星期天）。

接下来的一行给出 N 个用一个空格隔开的、小于 60 的整数，第 i 个数表示第 i 天的温度。保证温度大于等于 -273 度。

输出格式:
输出两个数，第一个是你能喝到免费雪碧的天数，第二个是你本来能喝到免费雪碧、但因为是星期四而无法喝到的天数。

输入样例:

15 3
33 35 34 36 37 40 32 31 30 29 28 29 33 38 40

输出样例:

5 1

签到题，基本都是无脑写代码。

import java.util.Scanner;

public class Main {
    static int ans=0;
    static int not_drink=0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        while(n-->0){
            m=m%7;
            int t=sc.nextInt();
            if(t>=35){
                if(m!=4){
                    ans++;
                }else{
                    not_drink++;
                }
            }
            m++;
        }
        System.out.println(ans+" "+not_drink);
    }
}

题目二、谁进线下了？

Xepa Legends 是一个第一人称射击类大逃杀（“吃鸡”）游戏，每轮游戏共有 20 支 3 人小队参加，最后获胜的队伍被称为“捍卫者”。

最近 Xepa Legends 举行了亚太地区南赛区的线上比赛，争夺 7 个前往德国曼海姆参加线下赛的资格，国内共有 14 支队伍参与到了其中。因为比赛十分激烈，直到最后谁进了线下仍有巨大的疑问。小 K 喜欢的国内知名战队 DreamTear 因其队内选手杀马特表现不佳，正好卡在出线分数前后，请你赶紧帮帮小 K，计算一下最后的分数情况，看看他喜欢的战队出线了没有吧！

Xepa Legends 的比赛共进行 N 场游戏，在每场游戏中，每支队伍在游戏中会获得一个排名和一个杀敌数（击败其他队伍玩家的数量），一支队伍在一场游戏的得分为杀敌数+排名分，排名分由队伍当场的排名根据以下表格求得：

排名	分数
第一名	12 分
第二名	9 分
第三名	7 分
第四名	5 分
第五名	4 分
第六名至第七名	3 分
第八名至第十名	2 分
第十一名至第十五名	1 分
第十六名至第二十名	0 分

例如，

• DreamTear 战队在第三场比赛获得了第三名、有 6 个杀敌数，那么他们将获得7 + 6 = 13分；
• KV 战队在第二场比赛获得了第 19 名、有 1 个杀敌数，那么他们将获得0 + 1 = 1 分；
• SRN 战队在第四场比赛获得了第 1 名、有 9 个杀敌数，那么他们将获得 12 + 9 = 21分。
  注：本题与实际情况无关，所有比赛规则、队伍、队员名称均为虚构。

输入格式:
输入第一行是一个正整数 N (≤20)，表示有 N 场比赛。

接下来有 N 部分输入，每部分是一场比赛的情况。对每一场比赛，信息共分 20 行，第 i 行（i=1,⋯,20）给出的两个非负整数 p 和 k 表示第 i 支队伍在这场比赛里获得了第 p 名、杀敌数为 k。

数据保证所有给定的情况中，排名永远大于等于 1 且小于等于 20，杀敌数小于等于 57。

输出格式:
输出 20 行，按编号从小到大依次输出队伍的编号及该队全部游戏结束时的总分。

输入样例:

3
6 2
7 3
11 5
10 1
2 9
5 8
14 3
4 3
1 6
18 1
12 1
20 0
13 0
3 2
16 4
8 1
19 0
9 4
17 1
15 0
8 2
19 1
12 2
1 9
10 1
7 5
18 0
14 0
5 2
4 4
2 5
6 2
16 3
13 1
20 0
3 7
9 3
15 0
17 5
11 3
18 0
5 2
2 9
9 4
4 7
10 3
16 0
1 6
20 0
15 1
6 0
3 6
14 3
7 4
19 0
17 0
8 9
11 0
13 5
12 0

输出样例:

1 9
2 13
3 27
4 30
5 33
6 25
7 4
8 27
9 24
10 12
11 19
12 18
13 8
14 18
15 4
16 17
17 16
18 8
19 12
20 6

也是签到题，看清楚题目，基本都是能AC的

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int[] arr ={0,12,9,7,5,4,3,3,2,2,2,1,1,1,1,1,0,0,0,0,0};
    public static void main(String[] args) {
        int[] a =new int[20];
        Arrays.fill(a,0);
        Scanner sc =new Scanner(System.in);
        int n=sc.nextInt();
        while(n-->0){
            for(int i=0;i<20;i++){
                int rank=sc.nextInt();
                int score=sc.nextInt();
                a[i]+=score;
                a[i]+=arr[rank];
            }
        }
        for(int i=0;i<20;i++){
            System.out.println(i+1+" "+a[i]);
        }
    }
}

题目三、暖炉与水豚

PapiCon（@PapilloteContet）出了许多有意思的谜题，其中有一道关于水豚的谜题是这样的：


来源：x.com/PapilloteContet

在一个 N×M 的矩阵中有若干水豚以及暖炉，暖炉可以辐射以它自身为中心的 3×3 范围里的水豚，使其变得暖呼呼的。谜题里存在一只冷的要命的水豚，你需要移动其中的一个暖炉，使所有水豚都变得暖呼呼的。

在往下读题前，如果你有兴趣的话，不妨思考一下如何解答这个谜题。（思考结果与题目无关，可跳过。）

这个谜题的关键在于，单纯从图中能看到的暖炉来说是无解的，但如果注意到，第 3 行第 6 列的水豚明明周围没有暖炉，却也处于暖呼呼的状态，就能推测出来图中的那个对话框挡住了一个暖炉，只要移动这个暖炉就可以完成题目的要求。

现在我们将谜题一般化，对于给定的一个 N×M 的矩阵、对应的所有水豚状态、以及能看到的暖炉摆放情况，已知最多只有一只水豚的状态不太对劲（周围没有暖炉却暖呼呼的），你需要推测有哪些格子可能藏了暖炉。一个空格可能藏了暖炉可以理解为：当前空格设置暖炉后整个矩阵的状态会从不合法变为合法。

输入格式:
输入第一行是两个正整数 N, M (1≤N,M≤1000)，表示矩阵的大小。

接下来的 N 行，每行有 M 个字符，第 i 行的第 j 个字符表示矩阵中对应位置的状态，其中：

• . 表示空格（或者说，看上去是空格的格子）；
• c 表示很冷的水豚；
• w 表示暖呼呼的水豚；
• m 表示暖炉。

输出格式:
输出若干行，每行两个正整数 r 和 c，表示第 r 行第 c 列有可能藏了一个暖炉，有多个可能时，先按 r 从小到大输出，r 相同时再按 c 从小到大输出。如果没有一个格子可能藏了暖炉， 则在一行中输出Too cold!。
行与列均从 1 开始编号。

输入样例:

6 8
wm....mw
.w..ww..
..wm.wwm
w.w....w
.m.c.m..
w.....w.

输出样例:

2 7
3 5
4 6
4 7

题主的想法就是，在输入的时候就记录每一个温暖小鼠和唯一一个寒冷小鼠的位置，然后对每一个温暖小鼠的周围进行九宫格遍历，该温暖小鼠每一个九宫格上没有暖炉的位置都打上标记（我这里使用Set集合，防止记录重复元素），最后遍历寒冷小鼠，因为寒冷小鼠周围没有暖炉，所以将前面集合里面包含的位置在集合里去掉，剩下就是可能的暖炉位置。

import java.util.*;

public class Main {
    static class dian {
        int x;
        int y;

        public dian(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            dian dian = (dian) o;
            return x == dian.x && y == dian.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int x1=0, x2=0;
        char[][] c = new char[n][m];
        sc.nextLine();
        for (int i = 0; i < n; i++) {
            c[i] = sc.nextLine().toCharArray();
        }
        List<dian> list = new ArrayList<>();  //记录温暖小鼠
        List<dian> set = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (c[i][j] == 'w') {   //将所有温暖小鼠的编号加进去
                    list.add(new dian(i, j));
                }
                if (c[i][j] == 'c') {
                    x1 = i;
                    x2 = j;
                }
            }
        }
        for (dian d : list) {
            int[] dx = {-1, -1, -1, 0, 0, 1, 1, 1};
            int[] dy = {-1, 0, 1, -1, 1, -1, 0, 1};
            boolean is = false; //表示在这个小鼠旁没找到暖炉
            for (int i = 0; i < 8; i++) {
                int d1 = d.x + dx[i];
                int d2 = d.y + dy[i];
                if (d1 < 0 || d1 >= n || d2 < 0 || d2 >= m) continue;
                if (c[d1][d2] == 'm') {
                    is = true;
                    break;
                }
            }
            if (is) continue;
            else {
                for (int i = 0; i < 8; i++) {
                    int d1 = d.x + dx[i];
                    int d2 = d.y + dy[i];
                    if (d1 < 0 || d1 >= n || d2 < 0 || d2 >= m) continue;
                    if(c[d1][d2]=='.') set.add(new dian(d1, d2));
                }
            }
        }
        int[] dx = {-1, -1, -1, 0, 0, 1, 1, 1};
        int[] dy = {-1, 0, 1, -1, 1, -1, 0, 1};
        for (int i = 0; i < 8; i++) {
            int d1 = x1 + dx[i];
            int d2 = x2 + dy[i];
            if (d1 < 0 || d1 >= n || d2 < 0 || d2 >= m) continue;
            dian d=new dian(d1,d2);
            if(set.contains(d)){
                set.remove(d);
            }
        }

        if(set.size()==0) System.out.println("Too cold!");
        else{
            for(dian d:set){
                System.out.println((d.x+1)+" "+(d.y+1));
            }
        }
    }
}

题目四、章鱼图的判断

对于无向图 G=(V,E)，我们将有且只有一个环的、大于 2 个顶点的无向连通图称之为章鱼图，因为其形状像是一个环（身体）带着若干个树（触手），故得名。

给定一个无向图，请你判断是不是只有一个章鱼子图存在。

输入格式:
输入第一行是一个正整数 T (1≤T≤5)，表示数据的组数。

每组数据的第一行是两个正整数 N,M (1≤N,M≤10^5 )，表示给定的无向图有 N 个点，M 条边。

接下来的 M 行，每行给出一条边两个端点的顶点编号。注意：顶点编号从 1 开始，并且题目保证任何边不会重复给出，且没有自环。

输出格式:
对于每组数据，如果给定的图里只有一个章鱼子图，则在一行中输出 Yes 和章鱼子图环的大小（及环中顶点数），其间以 1 个空格分隔。

否则，则在一行中输出 No 和图中章鱼子图的个数，其间以 1 个空格分隔。

输入样例:

3
10 10
1 3
3 5
5 7
7 9
1 2
2 4
2 6
3 8
9 10
1 9
10 10
1 3
3 5
5 7
7 9
9 1
1 2
2 4
4 8
8 10
10 1
10 10
1 3
3 5
5 7
7 9
9 1
2 4
4 8
8 10
10 2
10 6

输出样例:

Yes 5
No 0
No 2

此题博主不会，直接猜答案，得了一分

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=0;i<n;i++){
            System.out.println("No 0");
        }
    }
}

题目五、工作安排

输出格式:
对于每组数据，输出小 K 能获得最多的报酬是多少。

输入样例:

3
5
1 2 50
3 3 100
1 5 1
3 2 5000
4 5 30
5
1 2 50
3 3 20
1 5 1
3 2 5000
4 5 30
5
1 2 50
3 3 100
1 5 1
3 2 5000
5 5 800

输出样例:

101
80
800

题主一开始采用了DFS算法，后面采取快读快写，但是结果没有变化，应该是算法没有优化好

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    static long max = Integer.MIN_VALUE;
    static int[] t;
    static int[] d;
    static int[] p ;
    static boolean[] is;
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");
    static String nextLine() throws IOException {// 读取下一行字符串
        return reader.readLine();
    }
    static String next() throws IOException {// 读取下一个字符串
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {// 读取下一个int型数值
        return Integer.parseInt(next());
    }

    static long nextLong() throws IOException {// 读取下一个int型数值
        return Long.parseLong(next());
    }

    static double nextDouble() throws IOException {// 读取下一个double型数值
        return Double.parseDouble(next());
    }
    public static void main(String[] args)throws  Exception {
//        Scanner sc =new Scanner(System.in);
        int n=nextInt();
        while(n-->0){
            int k=nextInt();
            int time=Integer.MIN_VALUE;
            max=Integer.MIN_VALUE;
            t =new int[k];
            d =new int[k];
            p =new int[k];
            is=new boolean[k];
            for(int i=0;i<k;i++){
                t[i]=nextInt();
                d[i]=nextInt();
                p[i]=nextInt();
                if(time<d[i]){
                    time=d[i];
                }
            }
            dfs(0,k,0,time);
            System.out.println(max);
        }
    }
    public static void dfs(int x,int k,int money,int time){
        if(money>max){
            max=money;
        }
        if(x>=time)  return;

        for(int i=0;i<k;i++){
            if(is[i]) continue;     //如果这个任务已经是做过了，下一轮
            if(x+t[i]>d[i])continue;
            is[i]=true;
            dfs(x+t[i],k,money+p[i],time);
            is[i]=false;
        }
    }
}

总的来说，题目整体不难，第四题因为实在没怎么学过图论，有点不知道怎么下手，题目当时考场的最终成绩是64分，属于中等水平，最后结果是广东省二等奖。