目录
RC-v1 另类单位圆
对于二维平面上的一个点，记其坐标为 (x,y)。通常当我们说到“单位圆”的时候，默认是指到原点 (0,0) 的欧氏距离（即 x2+y2）为 1 的所有点构成的曲线。现在考虑“距离”的另一种定义，令 (x,y) 到原点 (0,0) 的另类距离为 ∣x2−xy−y2∣，则在这个另类距离下的单位圆就在二维平面上形成了另外形状的曲线。
本题给定一个正整数区间 [a,b]，求正整数坐标 (x,y)∈[a,b]×[a,b] 范围内，另类单位圆上到原点 (0,0) 的欧氏距离最小和最大的点坐标。
输入格式：
输入在一行中给出闭区间的两个端点，即正整数 a 和 b（1≤a≤b≤104）。
输出格式：
第一行输出到原点 (0,0) 的欧氏距离最小的点坐标，第二行输出到原点 (0,0) 的欧氏距离最大的点坐标。格式均为 (x, y)。
题目保证解存在且唯一。
输入样例：
10 1000输出样例：
(21, 13)
(987, 610)提示:
| 代码长度限制 | 16 KB |
| 时间限制 | 400 ms |
| 内存限制 | 64 MB |
代码思路:
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
int mini = Integer.MAX_VALUE;
int minj = Integer.MAX_VALUE;
int maxi = Integer.MIN_VALUE;
int maxj = Integer.MIN_VALUE;
for (int i = a; i <= b; i++) {
for (int j = a; j <= b; j++) {
if (i * i - i * j - j * j == 1 || i * i - i * j - j * j == -1) {
if (i < mini && j < minj) {
mini = i;
minj = j;
}
if (i > maxi && j > maxj) {
maxi = i;
maxj = j;
}
}
}
}
System.out.printf("(%d, %d)\n", mini, minj);
System.out.printf("(%d, %d)\n", maxi, maxj);
}
}
RC-v2 含茶量
ChatGPT（全名：Chat Generative Pre-trained Transformer）近期成为网络讨论的热点话题之一。本题就请你根据某社交网络中发帖的情况，统计每个人帖子中含有 ChatGPT（不区分大小写）的数量（简称“含茶量”），找出最热衷于讨论这个话题的人，即含茶量排前三的人。
输入格式：
输入在第一行中给出正整数：N（≤104），为参加统计的帖子数量。
随后给出 N 条帖子的信息，每条格式为：第一行给出发帖人 ID，是一个长度不超过 10 位的非空数字串；第二行给出非空的帖子的内容，由不超过 140 个英文字母、数字、空格、标点（只包括 ?、, 和 .）组成，以回车结束（回车不算在 140 字内）。
输出格式：
分三行输出含茶量最高的前三个 ID，及其含茶量。有并列时按 ID 的字典序递增输出；如果有含茶量的 ID 不到三个，那么有几个就输出几个，但含茶量为 0 的不要输出。数字间以 1 个空格分隔，行首尾不得有多余空格。
题目保证至少有一个输出。
输入样例：
5
1010
I am not interested in ChatGPT.
233
I am gonna talk about chatgpt, and Chatgpt, and CHATGPT
233
they are all ChatGPT
2
I am gonna talk about chatgpt, and Chatgpt, and CHATGPT
0002
chatgp, hatGPT and Chatppt, are they all ChatGPTs?
输出样例：
233 4
2 3
0002 1
注意:
2 和 0002 是两个不同的 ID。
提示:
| 编译器 | Java (javac) | Java (javac) | 其他编译器 | 其他编译器 |
| 代码长度限制 | 时间限制 | 内存限制 | 时间限制 | 内存限制 |
| 16 KB | 700 ms | 256 MB | 200 ms | 64 MB |
代码思路:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class Main{
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
int N = Integer.parseInt(br.readLine());
Map<String, Integer> map = new HashMap<String, Integer>();
while (N-- > 0) {
String string1 = br.readLine();
String string2 = br.readLine();
int num = 0;
for (int i = 0; i < string2.length() - 6; i++) {
if (string2.substring(i, i + 7).equalsIgnoreCase("ChatGPT")) {
num++;
}
}
if (num != 0) {
map.put(string1, map.getOrDefault(string1, 0) + num);
}
}
List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(map.entrySet());
list.sort(new Comparator<Entry<String, Integer>>() {
@Override
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
if (o1.getValue() != o2.getValue()) {
return o2.getValue() - o1.getValue();
} else {
return o1.getKey().compareTo(o2.getKey());
}
}
});
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Math.min(3, list.size()); i++) {
Entry<String, Integer> temp = list.get(i);
sb.append(temp.getKey());
sb.append(" ");
sb.append(temp.getValue());
sb.append("\n");
}
out.print(sb);
out.flush();
out.close();
}
}
RC-v3 软件窗体的层级管理
在应用软件的界面中有很多选项，有些选项点开后会出现弹出窗体，而弹出的窗体界面上又有一些选项，点开后还会出现弹出窗体…… 这里我们简单假设，任何一个窗体都仅由唯一的一个选项按钮激发，并且不存在自己激发自己的窗体。
本题就请你帮助完成一个统计任务，对任一给定的按钮，给出从这个按钮出发，可以弹出最多窗体的界面是哪一层，一共能弹出多少个窗体？我们称给定按钮所在的窗体为第 1 层，同一层窗体中所有选项激发的窗体都属于下一层。
设应用软件一共设计有 N（<100）个窗体，每个窗体有一个两位数的代号，从 00 编号到 N−1。初始界面窗体的代号为 00。样例给出了一个有 23 个窗体的应用软件组织结构图，如下图所示。如果指定初始界面（即 00）为第 1 层的话，可以弹出最多窗体的界面是第 4 层，共有 9 个窗体；如果指定 06 号窗体为第 1 层，则相对于 06 的下面第 2 层窗体最多，有 2 个。
当有若干层弹出最多窗体数量相同时，你只需要找到最高的那个最多窗体层级即可。例如指定 09 为第 1 层时，其下方第 2、3 层都只弹出 1 个窗口，于是第 1、2、3 层的窗体数量是相同的，这时应该返回最高的第 1 层作为答案。
输入格式：
输入在第一行中给出 2 个整数：N（0<N<100）为应用软件窗体总数，M（0≤M<N）为有弹出窗体选项的窗体的数量。随后 M 行，每行给出一个窗体的选项信息，格式为：
ID K ID[1] ID[2] ... ID[K]其中 ID 是该窗体的代号，K (>0) 是弹出窗体选项数，后面给出选项对应的窗体的代号。
接下来是一个正整数 T（≤10），最后一行给出 T 个被查询的窗体的代号。
同一行中所有数字都以空格分隔。
输出格式：
对每个被查询的窗体，在一行中输出两个数字：从这个窗体出发，可以弹出最多窗体的界面是哪一层，一共能弹出多少个窗体。数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：
23 13
21 1 01
00 4 03 02 04 05
03 3 06 07 08
06 2 12 13
13 1 21
08 2 15 16
02 2 09 10
11 2 19 20
17 1 22
05 1 11
07 1 14
09 1 17
10 1 18
4
00 06 09 20输出样例：
4 9
2 2
1 1
1 1提示:
| 编译器 | Java (javac) | Java (javac) | 其他编译器 | 其他编译器 |
| 代码长度限制 | 时间限制 | 内存限制 | 时间限制 | 内存限制 |
| 16 KB | 500 ms | 256 MB | 400 ms | 64 MB |
代码思路:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
public class Main{
static int lysans;
static int maxans;
static Map<String, ArrayList<String>> map = new HashMap<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
while (M-- > 0) {
String ID = scanner.next();
if (!map.containsKey(ID)) {
map.put(ID, new ArrayList<String>());
}
int k = scanner.nextInt();
for (int i = 0; i < k; i++) {
String temp = scanner.next();
map.get(ID).add(temp);
}
}
int T = scanner.nextInt();
while (T-- > 0) {
String string = scanner.next();
bfs(string);
System.out.printf("%d %d\n", lysans, maxans);
}
}
static void bfs(String string) {
lysans = 0;
maxans = 0;
int layers = 0;
Queue<String> queue = new LinkedList<String>();
queue.add(string);
while (!queue.isEmpty()) {
layers++;
int T = queue.size();
if (T > maxans) {
lysans = layers;
maxans = T;
}
while (T-- > 0) {
String temp = queue.poll();
if (map.containsKey(temp)) {
for (String string1 : map.get(temp)) {
queue.add(string1);
}
}
}
}
}
}
RC-v4 加号放哪里
给定任一个正整数 N，我们要从它开始，经过一系列操作得到一个个位数。操作方法是在 N 的各位数字之间放置一个加号，然后执行这个加法计算，得到一个新的数字 N1，再对 N1 执行同样操作，得到 N2 …… 以此类推，直到最后得到的数字只有 1 位，则停止。
例如我们从 N=1234567890 出发，在 5 和 6 之间放置加号，计算 12345+67890=80235；然后在 0 和 2 之间放置加号，计算 80+235=315；然后在 1 和 5 之间放置加号，计算 31+5=36；最后在 3 和 6 之间放置加号，得到 3+6=9 而停止。这样我们通过 4 次计算得到了一个个位数 9。
本题就请你为任一给定的正整数计算：最少需要多少次加号放置可以得到个位数？
注意：加号必须放置在两个数字之间，不可放置在数字的首尾。
输入格式：
输入在一行中给出一个正整数 n（≤1020）。
输出格式：
在一行中首先输出将输入的整数变为个位数，需要放置加号的最少次数；随后输出最后得到的那个个位数。如果最后得到的个位数不唯一，输出最小的那个。
数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：
1234567890输出样例：
3 9样例解释：
最优划分是：
- 12345678+90=12345768
- 1234+5768=7002
- 7+002=9
提示:
| 编译器 | Java (javac) | Java (javac) | 其他编译器 | 其他编译器 |
| 代码长度限制 | 时间限制 | 内存限制 | 时间限制 | 内存限制 |
| 16 KB | 500 ms | 256 MB | 400 ms | 64 MB |
代码思路:
import java.math.BigInteger;
import java.util.Scanner;
public class Main{
static long ansfqy = Long.MAX_VALUE;
static long ansnum = 10;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// n≤10^20 数据太大在Java中只能用String来存.
String n = scanner.nextLine();
// 数据长度小于19的用long就可以了.
if (n.length() < 19) {
justdfs(Long.parseLong(n), 0);
} else
// 数据长度大于等于19的则一定要使用BigInteger.
{
exceeddfs(n, 0);
}
System.out.printf("%d %d", ansfqy, ansnum);
}
// 普通.
static void justdfs(long n, long frequency) {
// 节支操作.
if (ansfqy < frequency) {
return;
}
if (n < 10 && (n < ansnum || frequency < ansfqy)) {
ansnum = n;
ansfqy = frequency;
return;
}
long temp = 10;
// while循环里的条件保证了nleft和nright不为零.
while (n / temp > 0) {
long nleft = n / temp;
long nright = n % temp;
temp *= 10;
justdfs(nleft + nright, frequency + 1);
}
}
// 大整数BigInteger.
static void exceeddfs(String n, long frequency) {
// 节支操作.
if (ansfqy < frequency) {
return;
}
for (int i = 1; i < n.length(); i++) {
BigInteger BIleft = new BigInteger(n.substring(0, i));
BigInteger BIright = new BigInteger(n.substring(i));
String string = BIleft.add(BIright).toString();
if (string.length() < 19) {
// 数据长度小于19了用justdfs运算更快.
justdfs(Long.parseLong(string), frequency + 1);
} else {
// 数据长度大于等于19继续用exceeddfs.
exceeddfs(string, frequency + 1);
}
}
}
}
扫一扫
116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
