第十届蓝桥杯b组java
ps : 历届蓝桥杯b组的题解用c写过了 ， 尝试用java写一下。。
1.组队：
作为篮球队教练，你需要从以下名单中选出1 号位至5 号位各一名球员，
组成球队的首发阵容。
每位球员担任1 号位至5 号位时的评分如下表所示。请你计算首发阵容1
号位至5 号位的评分之和最大可能是多少？
思路：手算即可，但是本人年纪大了，眼神不好，所以用dfs做的。
答案：490
package com.Test.Demo;
import java.util.Arrays;
public class OjTest {
//20个人选五个 求最大值
private static int ans=0;
private static int[] book=new int[20];
private static int[][] a=new int[][]{
{97,90,0,0,0},
{92,85,96,0,0},
{0,0,0,0,93},
{0,0,0,80,86},
{89,83,97,0,0},
{82,86,0,0,0},
{0,0,0,87,90},
{0,97,96,0,0},
{0,0,89,0,0},
{95,99,0,0,0},
{0,0,96,97,0},
{0,0,0,93,98},
{94,91,0,0,0},
{0,83,87,0,0},
{0,0,98,97,98},
{0,0,0,93,86},
{98,83,99,98,81},
{93,87,92,96,98},
{0,0,0,89,92},
{0,99,96,95,81}};
public static void main(String[] args){
Arrays.fill(book,-1);
dfs(0);
System.out.println(ans);
}
public static void dfs(int x) { //选了x个位置
if(x==5){
int sum=0;
for(int i=0;i<20;i++){
if(book[i]!=-1){
sum+=a[i][book[i]];
}
}
if(sum>ans){
ans=sum;
}
return ;
}
for(int i=0;i<20;i++){
if(book[i]==-1){
book[i]=x;
dfs(x+1);
book[i]=-1;
}
}
}
}2.不同的子串：
一个字符串的非空子串是指字符串中长度至少为1 的连续的一段字符组成
的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共7 个。
注意在计算时，只算本质不同的串的个数。
请问，字符串0100110001010001 有多少个不同的非空子串？
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
思路：利用截取字符串的方法，枚举长度和起点 ，截得所有子串，将其加到Set集合中去重，最后输出集合长度即可。
答案：100
代码：
package com.Test.Demo.WuQiShuZu;
import java.util.HashSet;
public class OjTest02 {
public static void main(String[] args){
//0100110001010001
String str="0100110001010001";
HashSet<String> hashSet=new HashSet();
for(int i=1;i<=16;i++){
for(int j=0;j+i-1<=16;j++){
String string = str.substring(j,j+i-1);
hashSet.add(string);
}
}
System.out.println(hashSet.size());
}
}3.数列求值：
给定数列1, 1, 1, 3, 5, 9, 17, …，从第4 项开始，每项都是前3 项的和。求
第20190324 项的最后4 位数字。
思路：类似于斐波那契 ， 不过填空题我们不必考虑超时，所以不用矩阵快速幂 ，直接取模求即可。
答案：4659
代码：
package com.Test.Demo.WuQiShuZu;
public class OjTest03 {
public static void main(String[] args){
/*给定数列1, 1, 1, 3, 5, 9, 17, …，从第4 项开始，每项都是前3 项的和。求
第20190324 项的最后4 位数字。*/
int f1=1,f2=1,f3=1,f4=3;
for(int i=4;i<=20190324;i++){
f4=(f1+f2+f3)%10000;
f1=f2;
f2=f3;
f3=f4;
}
System.out.println(f4);
}
}4.数的分解：
把2019 分解成3 个各不相同的正整数之和，并且要求每个正整数都不包
含数字2 和4，一共有多少种不同的分解方法？
注意交换3 个整数的顺序被视为同一种方法，例如1000+1001+18 和
1001+1000+18 被视为同一种。
答案：40785
思路：水
代码：
package com.Test.Demo.WuQiShuZu;
public class OjTest04 {
private static int ans=0;
public static void main(String[] args){
for(int i=1;i<=2019;i++){
for(int j=i+1;j<=2019;j++){
for(int k=j+1;k<=2019;k++){
if(i+j+k==2019&&ok(i)&&ok(j)&&ok(k)){
ans++;
}
}
}
}
System.out.println(ans);
}
public static boolean ok(int x){
while(x!=0){
int s=x%10;
x/=10;
if(s==2||s==4){
return false;
}
}
return true;
}
}5.迷宫：
下图给出了一个迷宫的平面图，其中标记为1 的为障碍，标记为0 的为可
以通行的地方。
010000
000100
001001
110000迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这
个它的上、下、左、右四个方向之一。
对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫，
一共10 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。
对于下面这个更复杂的迷宫（30 行50 列），请找出一种通过迷宫的方式，
其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。
请注意在字典序中D<L<R<U。
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个字符串，包含四种字母D、U、L、R，在提交答案时只填写这个字符串，填写多余的内容将无法得分。
思路：最短路径 ，bfs，记录一下路径信息即可 。
答案：DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
代码：
package com.Test.Demo.WuQiShuZu;
import java.util.LinkedList;
import java.util.Scanner;
public class OjTest05 { //D<L<R<U。 D、U、L、R 分别表示向下、向上、向左、向右走。
private static int flag = 0;
private static int[][] bb = new int[30][50];
private static String[] aa =new String[30];
private static int[][] next = {{1,0},{0,-1},{0,1},{-1,0}};
public static void main(String[] args) {
LinkedList<LuJing> luJings =new LinkedList<>();
Scanner scanner = new Scanner(System.in);
for(int i=0;i<30;i++){
aa[i]=scanner.next();
}
char[][] ch = new char[30][];
for(int i=0;i<30;i++){
ch[i]=aa[i].toCharArray();
}
LuJing temp = null;
bb[0][0]=1;
luJings.add(new LuJing(0,0,0,null));
while(luJings.size()!=0){
int x0=luJings.peek().x;
int y0=luJings.peek().y;
for(int i=0;i<4;i++){
int tx=x0+next[i][0];
int ty=y0+next[i][1];
if(tx>=0&&tx<30&&ty>=0&&ty<50&&ch[tx][ty]!='1'&&bb[tx][ty]==0){
temp = new LuJing(tx,ty,i,luJings.peek());
luJings.add(temp);
bb[tx][ty]=1;
}
if(tx==29&&ty==49){
flag=1;
break;
}
}
if(flag==1){
break;
}
luJings.poll();
}
StringBuffer stringBuffer = new StringBuffer();
while(temp.supe!=null){//D<L<R<U
if(temp.sup==0){
stringBuffer.append("D");
}else if(temp.sup==1){
stringBuffer.append("L");
}else if(temp.sup==2){
stringBuffer.append("R");
}else{
stringBuffer.append("U");
}
temp = temp.supe;
}
StringBuffer stringBuffer1=stringBuffer.reverse();
System.out.print(stringBuffer1);
}
}
class LuJing{
int x;
int y;
int sup;
LuJing supe;
public LuJing() {
}
public LuJing(int x, int y, int sup, LuJing supe) {
this.x = x;
this.y = y;
this.sup = sup;
this.supe = supe;
}
}6.特别数的和：
小明对数位中含有2、0、1、9 的数字很感兴趣（不包括前导0），在1 到
40 中这样的数包括1、2、9、10 至32、39 和40，共28 个，他们的和是574。
请问，在1 到n 中，所有这样的数的和是多少？
输入：
输入一行包含一个整数n。
输出：
输出一行，包含一个整数，表示满足条件的数的和。
【样例输入】
40
【样例输出】
574
思路：水。。。
package com.Test.Demo.WuQiShuZu;
import java.util.Scanner;
public class OjTest06 {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int s=0;
for(int i=1;i<=n;i++){
if(!ok(i)){
s+=i;
}
}
System.out.print(s);
}
public static boolean ok(int x){
while(x!=0){
int temp = x%10;
x/=10;
if(temp==2||temp==0||temp==1||temp==9){
return false;
}
}
return true;
}
}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 号) 在优先缓存中。
思路：我们把每个店的信息和每个店的订单信息存在一个Map集合里面 其中Map集合key部分为外卖店对象 value部分为此店的订单信息(存在一个List集合中) 对每个店的订单时间进行排序 遍历订单 计算得出优先级
代码：
package com.Test.Demo.oj;
import java.util.*;
public class Main01 {
// 对每家店进行判断 t 时刻的优先级是多少 是否大于5
// id封装成一个类 订单储存在List集合中
// 整个订单信息存在map集合中
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); // n 家店
int m = sc.nextInt(); // m条订单
int t = sc.nextInt();// t时刻
int ans = 0;
boolean[] book = new boolean[n+1];
HashMap<Node,List<Integer>> hashMap = new HashMap<>();
while((m--)>0){
int ts = sc.nextInt();
int id = sc.nextInt();
if(hashMap.containsKey(new Node(id))){
List<Integer> list = hashMap.get(new Node(id));
list.add(ts);
}else{
List<Integer> list = new LinkedList<>();
list.add(ts);
hashMap.put(new Node(id),list);
}
}
Set<Node> set = hashMap.keySet(); //将所有有订单的店铺取出 放在Set集合中
for(Node node :set){
List<Integer> list = hashMap.get(node); //通过店铺在map集合中获得订单信息
Collections.sort(list); //将所有订单按照升序排序
int count = 0; // 记录当前店铺的优先级
int time = 0;// 记录当前的时刻
int frist = 0;//记录最后一个订单时间
boolean flag = false; //记录当前店铺是否在优先队列
for(int temp : list){
while(time<temp-1){
count--;
time ++;
if(count<=0){
count=0;
}
if(flag&&count<=3){
ans--;
flag = false;
book[node.id] = false;
}
}
if(time<temp){
time++;
count+=2;
}
else{
count+=2;
}
if(!flag&&count>5){
ans++;
flag = true;
book[node.id] = true;
}
frist = temp;
}
if(frist!=t&&flag){
count -= (t-frist);
if(count<=3){
ans--;
book[node.id] = false;
}
}
}
System.out.print(ans);
}
}
class Node{
int id;
public Node(int id) {
this.id = id;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Node node = (Node) o;
return id == node.id;
}
@Override
public int hashCode() {
return Objects.hash(id);
}
}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 个字符。
注意:
Alice 和Bob 是大小写敏感的，alice 或bob 等并不计算在内。
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
思路：
代码：截取字符串 ， 获得每个名字的首字母所处的位置 ，统计每个名字前面k个字符内另一个名字出现的次数即可。
package com.Test.Demo.WuQiShuZu;
/*import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;*/
import java.util.*;
public class OjTest08{
private static String string;
private static int ans=0;
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
ArrayList<Integer> a = new ArrayList<>();
ArrayList<Integer> b = new ArrayList<>();
scanner.useDelimiter("\n");
int k = scanner.nextInt();
string = scanner.next();
for(int i=0;i+5<=string.length();i++) { //获取所有Alice和Bob单词首字母的位置
if ((i == 0 ||ok(i - 1 )) && ( i + 5 == string.length()|| ok(i + 5)) ) {
if(string.substring(i, i + 5).equals("Alice")){
a.add(i);
}
}
}
for(int i=0;i+3<=string.length();i++){
if ((i == 0 || ok(i - 1)) && ( i + 3 == string.length()|| ok(i + 3)) ) {
if(string.substring(i, i + 3).equals("Bob")){
b.add(i);
}
}
}
for(int i=0;i<a.size();i++){
int r = 0;
int l = 0;
while(r<b.size()&&a.get(i)>b.get(r)){
r++;
}
while(l<r&&a.get(i)>b.get(l)+k+3){
l++;
}
ans+=(r-l);
}
for(int i=0;i<b.size();i++){
int r = 0;
int l = 0;
while(r<a.size()&&b.get(i)>a.get(r)){
r++;
}
while(l<r&&b.get(i)>a.get(l)+k+5){
l++;
}
ans+=(r-l);
}
System.out.print(ans);
}
public static boolean ok(int x){ //判断制定索引处是否为单词 不是单词返回true
char ch = string.charAt(x);
if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z')){
return false;
}else{
return true;
}
}
}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
思路：特殊情况：m=0，直接输出和
一般情况：把所有数排个序，最大的拿出来，放首项，把最小的数拿出来，给他一个减号，再套一个括号，那么现在还未完成的表达式长这样：
可以发现，现在如果我想加一个数的话，给它一个加号，放在括号外面，也可以给它一个减号，放在括号里面；减一个数同理。换句话说，只要用一个减号，一个最大值，一个最小值，其他数我想加就加，想减就减。那么为了使结果最大，我加上正数，减去负数，就是直接加上所有剩下数的绝对值，那么就解决了
代码：
package com.Test.Demo.WuQiShuZu;
import java.util.*;
public class OjTest09 {
public static void main(String[] args) {
Scanner scanf = new Scanner(System.in);
long n = scanf.nextLong();
long m = scanf.nextLong();
int k = (int)(n+m+1);
long sum = 0;
long ans = 0;
long[] array = new long[k];
for(int i=0;i<k;i++) {
array[i] = scanf.nextInt();
sum+=array[i];
}
if(m==0) {
System.out.println(sum);
}else {
Arrays.sort(array);
ans-=array[0];
ans+=array[k-1];
for(int i=1;i<array.length-1;i++) {
ans+=Math.abs(array[i]);
}
System.out.println(ans);
}
}
}水平有限，不足之处请指正。
