day02 第十三届蓝桥杯国赛 JavaB

day02

🎉前言:每日更新!不断更!,周内一天一题.周末算法精析

✨更新地址:Royeblog

🎆🎆第十三届国赛javaB 试题C: 左移右移

🎉题目链接:题号2219

✨简单描述题目:

【问题描述】
小蓝有一个长度为N 的数组，初始时从左到右依次是1;2; 3; : : : N。 之后小蓝对这个数组进行了M 次操作，每次操作可能是以下2 种之一：

左移x，即把x 移动到最左边。
右移x，即把x 移动到最右边。
请你回答经过M 次操作之后，数组从左到右每个数是多少？
【输入格式】
第一行包含2 个整数，N 和M。 以下M 行每行一个操作，其中“L x”表示左移x，“R x”表示右移x。
【输出格式】
输出N 个数，代表操作后的数组。
【样例输入】

5 3
L 3
L 2
R 1

【样例输出】

2 3 4 5 1

【样例说明】
样例中的数组变化如下：
[1; 2; 3; 4; 5]
[3; 1; 2; 4; 5]
[2; 3; 1;4; 5]
[2; 3; 4; 5; 1]
【评测用例规模与约定】
对于50% 的评测用例，1<=N; M <= 10000:
对于100% 的评测用例，1 <= N; M <= 200000; 1 <= x <= N:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class C左移右移 {
    public static void main(String[] args) throws IOException {

        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        String[] s = bf.readLine().split(" ");
        int n = Integer.parseInt(s[0]);
        int k = Integer.parseInt(s[1]);
        int[][] arr=new int[n+1][2];

        for (int i = 1; i <= n; i++) {
            arr[i][0]=i;
            arr[i][1]=i;
        }
        int min=1;
        int max=n;
        for (int i = 0; i < k; i++) {
            String[] s1 = bf.readLine().split(" ");
            int num= Integer.parseInt(s1[1]);
            if ("L".equals(s1[0])){
                arr[num][1]=--min;
            }else {
                arr[num][1]=++max;
            }
        }
        
        Arrays.sort(arr,1,n+1, Comparator.comparingInt(o -> o[1]));
        System.out.print(arr[1][0]);
        for (int i = 2; i < arr.length; i++) {
            System.out.print(" "+arr[i][0]);
        }
    }
}

看数据量,不会直接暴力模拟有50分,🙄最大数据量还在int内,直接附着数,利用二位数组下标0上表示该数,下标1表示数的排序,开始时移到最左边就是把下标更新到min,min–更新,反之亦然;然后按照下标1排序输出

🎆🎆第十三届国赛javaB 试题D: 窗口

🎉题目链接:题号2220

✨简单描述题目:

【问题描述】
在平时使用电脑的过程中，经常会打开各种各样的窗口，各个窗口会在桌 面上重叠，并按照一定的层次关系显示。有的窗口能够看到全部内容，而有的窗口只能看到局部。 现在给定一组操作桌面窗口的过程序列，请你通过ASCII 艺术图来绘制最 后桌面的状态。 已知桌面的大小为N * M，即桌面高度为N 个像素，宽度为M 个像素， 其中左上角坐标为(0; 0)，右下角坐标为(N - 1; M - 1)。
对于窗口的操作有如下5 种：

new 操作- 打开一个新窗口 new [PID] [top] [left] [height] [width] 如：new 12 20 30 80 100 表示打开一个PID 为12 的窗口，窗口左上角的坐标为(20; 30)，该窗口宽 度为100 个像素，高度为80
个像素；新创建的窗口，其层级为顶层。
move 操作- 移动一个窗口 move [PID] [vertical] [horizontal] 如: move 12 -5 10 表示将PID 为12 的窗口在垂直方向上移动􀀀5 个像素，在水平方向上移 动10 个像素。若窗口左上角原位置为(20;
30)，此时则在(15; 40)；移动后的窗 口，其层级为顶层。
resize 操作- 改变窗口大小 resize [PID] [height] [width] 如：resize 12 90 110 表示保持左上角坐标不变的情况下，改变PID 为12 的窗口大小，调整为 试题D: 窗口6 第十三届蓝桥杯大赛软件赛决赛Java大学B组
高度90 像素，宽度110 像素；改变大小后的窗口，其层级为顶层。
close 操作- 关闭窗口 close [PID] 如：close 12 表示关闭PID 为12 的窗口；
active 操作- 激活窗口 active [PID] 如：active 12 表示激活PID 为12 的窗口，此时该窗口的层级被置为顶层。
【输入格式】
第1 行：2 个正整数N; M，表示桌面大小；
第2 行：1个正整数K，表示操作序列的长度；
第3 - K + 2 行：每行一个操作，格式见题目描述。
【输出格式】
第1-N行：每行M 个字符，仅包含‘.’, ‘+’, ‘-’, ‘|’, ‘ ’ 五种字符。 ‘.’ 表示桌面背景，即该部分未被任何窗口覆盖，‘+’表示窗口的四个角，‘-’ 表示窗口的横边, ‘|’ 表示窗口的竖边，‘ ’ 表示窗口内部。
【样例输入】

7 10
8
new 1 0 3 2 5
new 2 4 4 2 5
new 3 3 3 4 6
resize 3 3 6
move 1 0 5
close 2
new 4 1 1 3 5
active 3

【样例输出】

........+-
.+---+..+-
.| |....
.+-+----+.
...| |.
...+----+.
..........

【评测用例规模与约定】
对于100% 的数据，1 <= N; M <= 256; 1 <= K <= 10000:
输入数据保证：
1.同一时间不会有两个相同PID 的窗口存在，可能存在关闭某个PID 的 窗口后，再新建一个同样PID 的窗口，PID 的取值范围为1 <= PID <= 100000；
2.同时存在的窗口数量不超过200 个；
3.窗口尺寸不会小于2 * 2，即窗口高度和宽度均不会小于2，不会大于 N * M；
4.窗口在移动过程中，可能有部分界面超出桌面显示范围；
5.所有输入的数值均不超过±100000。
move resize close 只会对未关闭的窗口操作。

import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {

	public static void main(String[] args) { new Main().run(); }
	
	char[][] desktop;
	
	int n, m;
	
	void run() {
		desktop = new char[n = nextInt()][m = nextInt()];
		PrintWriter out = new PrintWriter(System.out);
		Queue<Window> queue = new PriorityQueue();
		Window[] windows = new Window[100001];
		for (int k = nextInt(); k-- > 0;) {
			String opt = next();
			int PID = nextInt();
			if (opt.equals("close")) windows[PID] = null;
			else {
				switch (opt) {
					case "new": 
						windows[PID] = 
							new Window(nextInt(), nextInt(), nextInt(), nextInt());
						break;
					case "move":
						windows[PID].
							move(nextInt(), nextInt());
						break;
					case "resize":
						windows[PID].
							resize(nextInt(), nextInt());
				}
				windows[PID].z = k;
			}
		}
		for (int i = 1; i <= 100000; ++i)
			if (windows[i] != null) queue.offer(windows[i]);
		while (queue.size() > 0) {
			Window now = queue.poll();
			int x1 = now.top, x2 = now.top + now.height - 1,
				y1 = now.left, y2 = now.left + now.width - 1;
			for (int i = x1 + 1; i < x2; ++i)
				for (int j = y1 + 1; j < y2; ++j) paint(i, j, ' ');
			for (int j = y1; j <= y2; ++j) {
				paint(x1, j, j > y1 && j < y2 ? '-' : '+');
				paint(x2, j, j > y1 && j < y2 ? '-' : '+');
			}
			for (int i = x1 + 1; i < x2; ++i) {
				paint(i, y1, '|');
				paint(i, y2, '|');
			}
		}
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < m; ++j)
				out.write(desktop[i][j] == '\0' ? '.' : desktop[i][j]);
			out.println();
		}
		out.flush();
	}
	
	void paint(int x, int y, char color) { if (x >= 0 && x < n && y >= 0 && y < m && desktop[x][y] == '\0') desktop[x][y] = color; }
	
	class Window implements Comparable<Window> {
		
		int z, top, left, height, width;
		
		Window(int top, int left, int height, int width) {
			this.resize(height, width);
			this.move(top, left);
		}
		
		void move(int vertical, int horizontal) {
			this.top += vertical;
			this.left += horizontal;
		}
		
		void resize(int height, int width) {
			this.height = height;
			this.width = width;
		}

		@Override
		public int compareTo(Window win) { return Integer.compare(this.z, win.z); }
	}
	
	StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	
	StreamTokenizer nextToken() {
		try {
			in.nextToken();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return in;
	}
	
	int nextInt() { return (int)nextToken().nval; }
	
	String next() { return nextToken().sval; }
}

模拟题,认真写!我难得写😎,随便看的官方题解

❗❗总结:好好学习每一天