A.求和
【问题描述】
小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包 括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。 请问，在 1 到 2019 中，所有这样的数的和是多少？
思路：
这题我跟用的强转，跟B组的F题很类似，直接输入2019就能得到答案
代码：
import java.util.Scanner;
public class 求和A {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
long sum=0;
for(int i=1;i<=n;i++){
String temp=i+"";
if(temp.contains("2")||temp.contains("0")||temp.contains("1")||temp.contains("9"))
sum+=i;
}
System.out.println(sum);
}
}
答案：1905111
B.矩形切割
【问题描述】
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。
当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为 5 和 3 的材料（记为 5×3），小明会依次切出 3×3、2×2、1×1、1×1 共 4 个正方形。 现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会 切出多少个正方形？
思路：
比较长和宽，找其中最小的值作为裁剪的正方形边长，这样就能使每一
次都能切出最大的正方形，一旦长和宽裁剪后的边长小于1，循环结束；
代码：
import java.util.Scanner;
public class 矩形切割 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int leng=2019;
int wide=324;
int ans=0; //答案
while(leng>=1&&wide>=1){
//找其中的最小值作为正方形的边长
if(leng>wide){
leng-=wide;
}
else{
wide-=leng;
}
ans++;
}
System.out.println(ans);
}
}
答案 ：21
C.不同子串
【问题描述】
一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？
思路：
先考虑所有的情况，再考虑去重；
1.所有情况：就是一个双重循环，以第一个数为开头的所有可能，
以第二个数为开头的所有可能.......;
2.去重：Java中Set集合可以去重；
代码：
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class 不同子串B {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String arr=input.next();
Set<String > set=new HashSet<String>();
for(int i=0;i<arr.length();i++){
//以i为开头的所有可能结果所以j必须大于i
for(int j=i+1;j<=arr.length();j++){
//虽然substring 下标i~j的时候是不包含j的
//每个数字开头本身也是个非空子串，也符合题意
//所以不需要变成substring(i,j+1)，
//由于需要包含到最后一个字符所以j最大值为arr,length();
String temp=arr.substring(i,j);
set.add(temp);
}
}
System.out.println(set.size());
}
}
答案：100
D.质数
【问题描述】
我们知道第一个质数是 2、第二个质数是 3、第三个质数是 5……请你计算 第 2019 个质数是多少？
代码：
import java.util.Scanner;
public class 质数D{
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int ans=0;
int res=0;//下面res++，就直接从1开始了改
while (ans<=2019){
res++;
if(check(res)){
ans++;
}
}
System.out.println(res);
}
public static boolean check(int nums){
int flag=0;
for(int i=2;i<nums;i++){
if(nums%i==0){
flag=1;
break;
}
}
if(flag==1)
return false;
else
return true;
}
}
答案：17569
E.最大降雨量
【问题描述】
由于沙之国长年干旱，法师小明准备施展自己的一个神秘法术来求雨。 这个法术需要用到他手中的 49 张法术符，上面分别写着 1 至 49 这 49 个 数字。法术一共持续 7 周，每天小明都要使用一张法术符，法术符不能重复使 用。 每周，小明施展法术产生的能量为这周 7 张法术符上数字的中位数。法术 施展完 7 周后，求雨将获得成功，降雨量为 7 周能量的中位数。 由于干旱太久，小明希望这次求雨的降雨量尽可能大，请大最大值是多少？
思路：
这题用代码真没想出来，看大佬的题解才发现，大佬是真的强，
我就直接放链接吧；
答案：49 - 15 = 34;
F.旋转
【问题描述】
图片旋转是对图片最简单的处理方式之一，在本题中，你需要对图片顺时 针旋转 90 度。 我们用一个 n×m 的二维数组来表示一个图片，例如下面给出一个 3×4 的 图片的例子：
1 3 5 7
9 8 7 6
3 5 9 7
这个图片顺时针旋转 90 度后的图片如下：
3 9 1
5 8 3
9 7 5
7 6 7
给定初始图片，请计算旋转后的图片。
【输入格式】
输入的第一行包含两个整数 n 和 m，分别表示行数和列数。 接下来 n 行，每行 m 个整数，表示给定的图片。图片中的每个元素（像 素）为一个值为 0 至 255 之间的整数（包含 0 和 255）。
【输出格式】
输出 m 行 n 列，表示旋转后的图片。
思路：
由画图可知，第一行的元素旋转后，会变成目标数组的最后一列，
第二行的元素旋转后，会变成目标数组的倒数第二列，由此可以
推出来规律了
代码：
import java.util.Scanner;
public class 旋转 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
int m=input.nextInt();
int resx=0;
int resy=0;
//最后输出数组的行和列
resx=m;
resy=n;
System.out.println(resx+" "+resy);
int [][]arr=new int[n+1][m+1];
int [][]temparr=new int[resx+1][resy+1];
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
arr[i][j]=input.nextInt();
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
temparr[j][resy-i+1]=arr[i][j];
}
}
for(int i=1;i<=resx;i++){
for(int j=1;j<=resy;j++){
System.out.print(temparr[i][j]+" ");
}
System.out.println();
}
}
}
G.外卖店优先级
【问题描述】
“饱了么”外卖系统中维护着 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。
8、人物相关性分析（编程题）（20分）
（时间限制: 1.0s 内存限制: 512.0MB）
这题我以前写过一个得百分之80混分版的，满分的实属没写来，
这篇混分版题解里有满分的链接在最后面，acwing里的小伙伴写的
蓝桥杯 外卖店的优先级 Java 易懂版 （80%得分考试混分版）
代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int N=input.nextInt();
int M=input.nextInt();
int T=input.nextInt();
List arr[]=new ArrayList[T+1];
int better[]=new int[N+1];
boolean level[]=new boolean[N+1];
for(int i=0;i<=T;i++){
arr[i]=new ArrayList();
}
for(int i=1;i<=M;i++){
int ts=input.nextInt();
int id=input.nextInt();
arr[ts].add(id); //t时刻有店铺id的订单，
}
for(int i=1;i<=T;i++){
for(int j=1;j<=N;j++){
int flag=0;
Object k=j;
while (arr[i].contains(k)){
flag=1;
better[j]+=2;
arr[i].remove(k);
if(better[j]>5)
level[j]=true;
}
if(flag==0) {
//此时刻无店铺j的订单
better[j] = better[j] == 0 ? 0 : better[j] - 1;
if (level[j]) {
//原来在缓存队列
if (better[j] <= 3) {
//优先级下降
level[j] = false;
}
}
}
}
}
int count=0;
for(int i=1;i<=N;i++){
if(level[i])
count++;
}
System.out.println(count);
}
}
H. 人物相关性分析
【问题描述】
小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob 有多少次同时出现。 更准确的说，小明定义 Alice 和 Bob“同时出现”的意思是：在小说文本 中 Alice 和 Bob 之间不超过 K 个字符。 例如以下文本：
This is a story about Alice and Bob.Alice wants to send aprivate 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 aprivate message to Bob.
思路:
1.这题比较困扰我的是这里一个“.”，“，”表示两个字符，但分割后我咋知
道有多少个点被算进去了， 别人的一种方法： str.split("\\s+|\\.")，
我觉得这样是有问题的，按照上面的方法 举个例子：
输入：This is a story about Alice.and.Bob.Alice wants to send aprivate message to Bob.
输出：This is a story about Alice and Bob Alice wants to send aprivate message to Bob
这样子Alice.and.Bob的距离是7，但在实际运算的时候我们并不知道中间会
有多少个字符，在我绞尽脑汁下，在网上看到这样一个方法很巧妙这是链接
https://www.jianshu.com/p/7342d800efa2；
2：大致思路是这样把所有的.变成“ab”，然后再按空格拆分，这个时候
Bob.Alice会变成Bob ab Alice这个时候计算长度的时候就要注意，具体
看代码；
3.Alice和Bob的前后顺序没关系，只要距离小于K就行了，因此需要找两边，
确定Alice后找Bob 和确定Bob后找Alice；
4.三重循环可能会超时，没有测试用例我也不清楚，因此用两重保险点，
三重是先确定Alice 然后再确定Bob，然后再用一个循环计算两者的长度
我们一遍找Bob一边记录长度，如果最后找的Bob符合要答案加1，不符合
根据判断条件无法更新答案，这样应该能优化点时间；
代码：
import java.util.Scanner;
public class 人物相关性格分析H {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
int res=0; //save result
int K=reader.nextInt();
reader.nextLine(); //nextLine吸取回车键
String str=reader.nextLine();
str=str.replaceAll("\\.", " ab ");
String []arr=str.split("\\s+");
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
int ans=0;//保存答案
//找每个Alice 后面有多少个合适的Bob
for(int i=0;i<arr.length;i++){
//找匹配的Alice
if(arr[i].equals("Alice")||arr[i].equals("Aliceab")){
int distance=1;//Alice 后面要是有单词肯定会有一个空格除非是最后一个数，最后一个数就不用考虑了
for(int j=i+1;j<arr.length;j++){
//找合适的Bob
if((arr[j].equals("Bob")||arr[j].equals("Bobab"))&&distance<=K){
ans++;
}
//没有就把这段距离加上免得用三重循环
else{
//Bob.Alice 会转化为 Bob ab Alice
//原本的长度是2转变后为4，因为会多两个空格
//所以当arr[j]为ab是不要加空格的长度，还要减去之前Bob后面的空格
if(arr[j].equals("ab")) {
distance += arr[j].length();
distance-=1;
}
else
distance+=arr[j].length()+1;
}
}
}
}
//找每个Bob后面有多少个符合的Alice
for(int i=0;i<arr.length;i++){
//找匹配的Alice
if(arr[i].equals("Bob")||arr[i].equals("Bobab")){
int distance=1;//Bob 后面要是有单词肯定会有一个空格
for(int j=i+1;j<arr.length;j++){
//找合适的Alice
if((arr[j].equals("Alice")||arr[j].equals("Alice"))&&distance<=K){
ans++;
}
//没有就把这段距离加上免得用三重循环
else{
//Bob.Alice 会转化为 Bob ab Alice
//原本的长度是2转变后为4，因为会多两个空格
//所以当arr[j]为ab是不要加空格的长度，还要减去之前Bob后面的空格
if(arr[j].equals("ab")) {
distance += arr[j].length();
distance-=1;
}
else
distance+=arr[j].length()+1;
}
}
}
}
System.out.println(ans);
}
}
I. 等差数列
【问题描述】
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一 部分的数列，只记得其中 N 个整数。 现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有 几项？
【输入格式】
输入的第一行包含一个整数 N。 第二行包含 N 个整数 A1,A2,··· ,AN。(注意 A1 ∼ AN 并不一定是按等差数 列中的顺序给出)
【输出格式】
输出一个整数表示答案。
【样例输入】 5 2 6 4 10 20
【样例输出】 10
【样例说明】
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、 18、20。
【评测用例规模与约定】
对于所有评测用例，2≤ N ≤100000，0≤ Ai ≤109。
10、扫地机器人（编程题）（25分）
（时间限制: 1.0s 内存限制: 512.0MB）
思路：
1.它们都是同一个等差数列的值，因此它们中间俩俩的差，肯定是
nd(d是公差)，因为要求最短的等差数列，因此只需求所有的
俩俩差的最大公约数，求出最大公约数剩下的就好求了，
为
2.在俩俩相减前要先排序，使求出的nd是正数，为了方便，我们
把除第一位的每一位减去排序后的第一位，这样的结果也是nd
代码：
import java.util.Arrays;
import java.util.Scanner;
public class 等差数列I{
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int N=input.nextInt();
int arr[]=new int[N+1];
for(int i=0;i<N;i++){
arr[i]=input.nextInt();
}
Arrays.sort(arr);
int Max=arr[N];
int Min=arr[1];
int d=0;
int cha[]=new int[N];
int index=0;
//找每个数与第一位的公差
for(int i=2;i<=N;i++){
cha[index++]=arr[i]-Min;
}
//找最大公差
for(int i=0;i<index;i++){
// int temp= gcd(cha[i-1],cha[i]);
d=gcd(cha[i],d);
}
//公差为0的时候原数组就是最小等差数列
if(d==0)
System.out.println(N);
else
System.out.println((Max-Min)/d+1);
}
public static int gcd(int a,int b){
if(b==0)
return a;
else {
return gcd(b,a%b);
}
}
}
J.扫地机器人
【问题描述】
小明公司的办公区有一条长长的走廊，由 N 个方格区域组成，如下图所示。
走廊内部署了 K 台扫地机器人，其中第 i 台在第 Ai 个方格区域中。 已知扫地机器人每分钟可以移动到左右相邻的方格中，并将该区域清扫干净。
请你编写一个程序，计算每台机器人的清扫路线，使得
(1)、它们最终都返回出发方格，
(2)、每个方格区域都至少被清扫一遍，
(3)、从机器人开始行动到最后一台机器人归位花费的时间最少。
注意多台机器人可以同时清扫同一方块区域，它们不会互相影响。
输出最少花费的时间。 在上图所示的例子中，最少花费时间是 6。第一台路线：2-1-2-3-4-3-2，清 扫了 1、2、3、4 号区域。第二台路线 5-6-7-6-5，清扫了 5、6、7。第三台路线 10-9-8-9-10，清扫了 8、9 和 10。
【输入格式】
第一行包含两个整数 N 和 K。 接下来 K 行，每行一个整数 Ai。
【输出格式】
输出一个整数表示答案。
【样例输入】 10 3 5 2 10
【样例输出】 6
【评测用例规模与约定】
对于 30% 的评测用例，1≤ K < N ≤10。 对于 60% 的评测用例，
1≤ K < N ≤1000。 对于所有评测用例，1≤ K < N ≤100000，
1≤ Ai ≤ N。
没写来还是太菜，别人的也没看懂