题目标签
| 1 | 2 | 3 | 4 | 5 | |||||
| 组队 | 不同子串 | 数列求值 | 数的分解 | 迷宫 | |||||
| 6 | 7 | 8 | 9 | 10 | |||||
| 特别数的和 | 外卖优先级 | 人物相关性分析 | 后缀表达式 | 灵能传输 |
1.组队
作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？
package 组队;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n[] = new int[20];
int a[] = new int[20];
int b[] = new int[20];
int c[] = new int[20];
int d[] = new int[20];
int e[] = new int[20];
for (int i = 0; i < 20; i++) {
n[i] = sc.nextInt();
a[i] = sc.nextInt();
b[i] = sc.nextInt();
c[i] = sc.nextInt();
d[i] = sc.nextInt();
e[i] = sc.nextInt();
}
int max = 0;
for (int i = 0; i < 20; i++) {
int sum = 0;
for (int j = 0; j < 20; j++) {
for (int l = 0; l < 20; l++) {
for (int k = 0; k < 20; k++) {
for (int p = 0; p < 20; p++) {
Set<Integer> set = new HashSet<Integer>();
set.add(n[i]);
set.add(n[j]);
set.add(n[l]);
set.add(n[k]);
set.add(n[p]);
if (set.size() == 5) {
sum = a[i] + b[j] + c[l] + d[k] + e[p];
if (sum > max) {
max = sum;
}
}
}
}
}
}
}
System.out.println(max);
}
}
2.不同子串
一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？
100
package 不同子串;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
String str = "0100110001010001";
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < str.length(); i++) {
for (int j = i+1; j <= str.length(); j++) {
System.out.println(str.substring(i,j));
set.add(str.substring(i,j));
}
}
System.out.println(set.size());
}
}3.数列求值
给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。
4569
package 不同子串;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
String str = "0100110001010001";
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < str.length(); i++) {
for (int j = i+1; j <= str.length(); j++) {
System.out.println(str.substring(i,j));
set.add(str.substring(i,j));
}
}
System.out.println(set.size());
}
}4.数的分解
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，一共有多少种不同的分解方法？ 注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
40785
package 数的分解;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
int num = 2019;
for (int i = 1; i < 2019; i++) {
if(f(i))
for (int j = 1; j < 2019; j++) {
if(f(j)){
int k = 2019-i-j;
if (f(k) && i+j+k==2019 && i!=j&&j!=k&&i!=k) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(i);
list.add(j);
list.add(k);
Collections.sort(list);
set.add(list.toString());
System.out.println(list);
}
}
}
}
System.out.println(set.size());
}
private static boolean f(int i) {
if(i<=0)return false;
String s = i+"";
return !s.contains("2")&&!s.contains("4");
}
}
5.迷宫
package 迷宫;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.TreeSet;
public class Main {
static int[] dx = {1,0,-1,0};
static int[] dy = {0,1,0,-1};
static int len_x = 30;
static int len_y = 50;
static char map[][] = new char[len_x][];
static boolean check[][] = new boolean[len_x][len_y];
static Stack<Character> sta = new Stack<Character>();
static int min_length = 1000000;
//static Stack<Character> min_stack = new Stack<Character>();
static TreeSet<String> set = new TreeSet<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// TODO Auto-generated method stub
if (o1.length() == o2.length())
return o1.compareTo(o2);
else
return o1.length()-o2.length();
}
});
// static Stack<Integer> x = new Stack<Integer>();
// static Stack<Integer> y = new Stack<Integer>();
// static Queue<Integer> x = new LinkedList<Integer>();
// static Queue<Integer> y = new LinkedList<Integer>();
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
for (int i = 0; i < map.length; i++) {
map[i] = sr.next().toCharArray();
}
// x.push(0);
// y.push(0);
check[0][0] = true;
dfs(0,0);
System.out.println("最小路径:");
System.out.println(set.first());
System.out.println(set);
}
@SuppressWarnings("unchecked")
private static void dfs(int i, int j) {
for (int k = 0; k < 4; k++) {
int nx = i + dx[k];
int ny = j + dy[k];
if (nx >= 0 && ny >= 0 && nx < len_x && ny < len_y && map[nx][ny]=='0' && !check[nx][ny]){
// x.push(nx);
// y.push(ny);
check[nx][ny] = true;
char c = 0;
switch (k) {
case 0:
c = 'D';
break;
case 1:
c = 'R';
break;
case 2:
c = 'U';
break;
case 3:
c = 'L';
break;
}
sta.push(c);
if (nx == len_x-1 && ny == len_y-1) {
// if (sta.size() < min_length ) {
// min_length = sta.size();
// min_stack = (Stack<Character>) sta.clone();
// }else if (sta.size() == min_length) {
// set.add(sta.toString());
// //min_stack = (Stack<Character>) sta.clone();
// System.out.println("tree: "+set.first());
// }
if (sta.size() <= min_length ) {
System.out.println(sta.size()+" "+sta);
min_length = sta.size();
set.add(sta.toString());
}
}
dfs(nx,ny);
check[nx][ny] = false;
// x.pop();
// y.pop();
sta.pop();
}
}
}
}
6.特别数的和
【问题描述】
小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。 请问，在 1 到 n 中，所有这样的数的和是多少？
【输入格式】 输入一行包含两个整数 n。
【输出格式】 输出一行，包含一个整数，表示满足条件的数的和。
【样例输入】 40
【样例输出】 574
对于 20% 的评测用例，1 ≤ n ≤ 10。 对于 50% 的评测用例，1 ≤ n ≤ 100。 对于 80% 的评测用例，1 ≤ n ≤ 1000。 对于所有评测用例，1 ≤ n ≤ 10000。
package 特别数的和;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n=in.nextInt();
in.close();
int count=0;
for(int x=1;x<=n;x++)
{
if(String.valueOf(x).contains("2")
||String.valueOf(x).contains("0")
||String.valueOf(x).contains("1")
||String.valueOf(x).contains("9")
)
{
count+=x;
}
}
System.out.println(count);
}
}
7.外卖优先级
“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。 每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。 如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。 给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优 先缓存中。
【输入格式】 第一行包含 3 个整数 N、M 和 T。 以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。
【输出格式】 输出一个整数代表答案。
【样例输入】
2 6 6 1 1 5 2 3 1 6 2 2 1 6 2
【样例输出】
1
【样例解释】 6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6， 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
【评测用例规模与约定】 对于 80% 的评测用例，1 ≤ N, M, T ≤ 10000。 对于所有评测用例，1 ≤ N, M, T ≤ 100000，1 ≤ ts ≤ T，1 ≤ id ≤ N。
package 外卖优先级;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();
int m = sr.nextInt();
int t = sr.nextInt();
int[] id = new int[n+1];//店号为下标
String[] orders = new String[t+1];
for (int i = 0; i < m; i++) {//订单列表
int time = sr.nextInt();
int tid = sr.nextInt();
orders[time] += (" "+tid);
}
System.out.println(Arrays.toString(orders));
//优先缓存
ArrayList<Integer> l = new ArrayList<Integer>();
for (int i = 1; i < orders.length; i++) {
if (orders[i]==null) {//这时刻没有接收到任何订单
//所有店面-1
for (int j = 1; j < id.length; j++) {
id[j] --;
if(id[j] <= 0)id[j] = 0;
if (id[j]<=3 && l.contains(j)) {//去除优先缓存
l.remove(l.indexOf(j));
}
}
}else {//接收到部分订单
int[] check = new int[n+1];//标记是否有订单
String[] ditel = orders[i].split(" ");
for (int j = 1; j < ditel.length; j++) {//完成标记
check[Integer.parseInt(ditel[j])]+=1;
}
//根据标记判断店面加减优先级
for (int j = 1; j < check.length; j++) {
if (check[j]==0) {//无订单
id[j] --;
if (id[j] < 0) {//最小等于零
id[j] =0;
}
if (id[j]<=3 && l.contains(j)) {//去除优先缓存
l.remove(l.indexOf(j));
}
}else {//有订单
id[j]+=2 * check[j];//有几个订单就+3*n
if (id[j]>5 && !l.contains(j)) {//加优先缓存
l.add(j);
}
}
}
}
};
System.out.println(l.size());
}
}
8.人物相关性分析
小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob 有多少次同时出现。 更准确的说，小明定义 Alice 和 Bob“同时出现”的意思是：在小说文本 中 Alice 和 Bob 之间不超过 K 个字符。
例如以下文本： This is a story about Alice and Bob. Alice wants to send a private message to Bob.
假设 K = 20，则 Alice 和 Bob 同时出现了 2 次，分别是”Alice and Bob” 和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符，后者有 2 个字符。 注意: 1. Alice 和 Bob 是大小写敏感的，alice 或 bob 等并不计算在内。 2. Alice 和 Bob 应为单独的单词，前后可以有标点符号和空格，但是不能 有字母。例如 Bobbi 並不算出现了 Bob。 【输入格式】 第一行包含一个整数 K。 第二行包含一行字符串，只包含大小写字母、标点符号和空格。长度不超 过 1000000。
【输出格式】 输出一个整数，表示 Alice 和 Bob 同时出现的次数。
【样例输入】
20 This is a story about Alice and Bob. Alice wants to send a private message to Bob.
【样例输出】 2
【评测用例规模与约定】 对于所有评测用例，1 ≤ K ≤ 1000000。
package 人物相关性分析;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
try {
int K = input.nextInt();
input.nextLine();
String text = input.nextLine();
//字符串分割，按照空格或.分割字符，若是（.空格）分割后为空字符串。
String[] words = text.split("\\s|\\.");
System.out.println(Arrays.toString(words));
int[] wordsLength = new int[words.length];
//将分割的字符串的长度值存储，避免三重循环中调用String.length();
for (int i = 0; i < words.length; i++) {
wordsLength[i] = words[i].length();
}
int num = 0;
//Alice ——> Bob的距离
for (int i = 0; i < words.length; i++) {
if (words[i].equals("Alice")) {
for (int j = i + 1; j < words.length; j++) {
int sum = 1;
if (words[j].equals("Bob")) {
for (int k = i + 1; k < j; k++) {
//每个单词的长度加空格占据的长度
sum += wordsLength[k] + 1;
}
if (sum <= K) {
num++;
}
}
}
}
}
//Bob ——> Alice的距离
for (int i = 0; i < words.length; i++) {
if (words[i].equals("Bob")) {
for (int j = i + 1; j < words.length; j++) {
int sum = 1;
if (words[j].equals("Alice")) {
for (int k = i + 1; k < j; k++) {
sum += wordsLength[k] + 1;
}
if (sum <= K) {
num++;
}
}
}
}
}
System.out.println(num);
} catch (Exception e) {
input.close();
}
}
}
9.后缀表达式
给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1, A2, · · · , AN+M+1，小 明想知道在所有由这 N 个加号、M 个减号以及 N + M + 1 个整数凑出的合法的 后缀表达式中，结果最大的是哪一个？ 请你输出这个最大的结果。 例如使用1 2 3 + -，则 “2 3 + 1 -” 这个后缀表达式结果是 4，是最大的。
【输入格式】 第一行包含两个整数 N 和 M。 第二行包含 N + M + 1 个整数 A1, A2, · · · , AN+M+1。
【输出格式】 输出一个整数，代表答案。
【样例输入】 1 1 1 2 3
【样例输出】 4
【评测用例规模与约定】 对于所有评测用例，0 ≤ N, M ≤ 100000，−109 ≤ Ai ≤ 109。
package 后缀表达式;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sr = new Scanner(System.in);
int n =sr.nextInt();
int m =sr.nextInt();
int len =n+m+1;
long arr[] = new long[len];
for (int i = 0; i < len; i++) {
arr[i] = sr.nextLong();
}
Arrays.sort(arr);
long sum = arr[arr.length-1];
for (int i = arr.length-1-1; i >= 0; i--) {
if (n != 0) {
sum += arr[i];
n--;
continue;
}
if (m != 0) {
sum -= arr[i];
m--;
}
}
System.out.println(sum);
}
}
10.灵能传输
在游戏《星际争霸 II》中，高阶圣堂武士作为星灵的重要 AOE 单位，在 游戏的中后期发挥着重要的作用，其技能”灵能风暴“可以消耗大量的灵能对 一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的 刺蛇飞龙等低血量单位。
【问题描述】 你控制着 n 名高阶圣堂武士，方便起见标为 1, 2, · · · , n。每名高阶圣堂武士 需要一定的灵能来战斗，每个人有一个灵能值 ai 表示其拥有的灵能的多少（ai 非负表示这名高阶圣堂武士比在最佳状态下多余了 ai 点灵能，ai 为负则表示这 名高阶圣堂武士还需要 −ai 点灵能才能到达最佳战斗状态）。现在系统赋予了 你的高阶圣堂武士一个能力，传递灵能，每次你可以选择一个 i ∈ [2, n − 1]，若 ai ≥ 0 则其两旁的高阶圣堂武士，也就是 i − 1、i + 1 这两名高阶圣堂武士会从 i 这名高阶圣堂武士这里各抽取 ai 点灵能；若 ai < 0 则其两旁的高阶圣堂武士， 也就是 i − 1, i + 1 这两名高阶圣堂武士会给 i 这名高阶圣堂武士 −ai 点灵能。形 式化来讲就是 ai−1+ = ai , ai+1+ = ai , ai− = 2ai。 灵能是非常高效的作战工具，同时也非常危险且不稳定，一位高阶圣堂 武士拥有的灵能过多或者过少都不好，定义一组高阶圣堂武士的不稳定度为 maxn i=1|ai |，请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武 士的不稳定度最小。
【输入格式】 本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。 接下来依次输入每一组询问。 每组询问的第一行包含一个正整数 n，表示高阶圣堂武士的数量。 接下来一行包含 n 个数 a1, a2, · · · , an。 试题 J: 灵能传输 15第十届蓝桥杯大赛软件类省赛Java大学B组
【输出格式】 输出 T 行。每行一个整数依次表示每组询问的答案。
【样例输入】 3 3 5 -2 3 4 0 0 0 0 3 1 2 3
【样例输出】 3 0 3
【样例说明】 对于第一组询问： 对 2 号高阶圣堂武士进行传输操作后 a1 = 3，a2 = 2，a3 = 1。答案为 3。 对于第二组询问： 这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。
【样例输入】 3 4 -1 -2 -3 7 4 2 3 4 -8 5 -1 -1 6 -1 -1
【样例输出】 5 7 4
321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
