devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【2023华为od机考】算法题答案记录100分题_华为前端od算法题

作者：繁依Fanyi0 | 2024-03-01 13:21:49

赞

踩

华为前端od算法题

准备od机考中, c++答案和java都有

标括号(博客)代表是题目链接里给的答案, 大部分是自己写的, 比较喜欢打上注释, 帮助理解

我觉得c++还是简洁点, 不过有的题目就是为了考java的集合用法, 就用java更好

题目链接

华为OD机试真题2023（JAVA&JS）_华为机试真题_若博豆的博客-CSDN博客

1 猜字谜

c++代码(我写的)

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5.  
  6. const int N = 20010;
  7.  
  8. string aa[N], bb[N];
  9.  
  10. int main()
  11. {
  12.     string a;//谜面
  13.     string b;//谜底 在谜底中找谜面里的错误词
  14.     
  15.     getline(cin, a);
  16.     getline(cin, b);
  17.     
  18.     string res;//每个单词
  19.     int count = 0;
  20.     for(int i = 0; i < a.length(); i ++ ) 
  21.     {
  22.         if(a[i] == ',') 
  23.         {
  24.             aa[count ++ ] = res;
  25.             res = "";
  26.         } 
  27.         else res += a[i];
  28.     } 
  29.     aa[count] = res;//最后一个res也存进去 count不用加了
  30.     int len_aa = count + 1;
  31.     
  32.     res = "";
  33.     count = 0;
  34.     for(int i = 0; i < b.length(); i ++ ) 
  35.     {
  36.         if(b[i] == ',') 
  37.         {
  38.             bb[count ++ ] = res;
  39.             res = "";
  40.         } 
  41.         else res += b[i];
  42.     } 
  43.     bb[count] = res;//最后一个res也存进去 count不用加了
  44.     int len_bb = count + 1;
  45.     
  46.     bool flag = false;//是否找到
  47.     bool comma = false;//是否有逗号
  48.     
  49.     //然后两个字符串数组就是 aa 和 bb, 长度分别是len_aa, len_bb
  50.     for(int i = 0; i < len_aa; i ++ ) {//循环aa字符串数组, 
  51.         string str = aa[i];
  52.         sort(str.begin(), str.end());
  53.         str.erase(unique(str.begin(), str.end()), str.end()); //去掉重复元素
  54.         for(int j = 0; j < len_bb; j ++ ) {
  55.             string str2 = bb[j];
  56.             sort(str2.begin(), str2.end());
  57.             str2.erase(unique(str2.begin(), str2.end()), str2.end());
  58.             
  59.             if(str2 == str) {
  60.                 if(comma) cout << ',';
  61.                 cout << bb[j];
  62.                 flag = true;
  63.                 comma = true;
  64.                 break;
  65.             }
  66.         }
  67.         if(flag == false) cout << "not found" << endl;
  68.         flag = false;
  69.     }
  70.     
  71.     return 0;
  72. }

java代码(博客里的):

  1. import java.util.*;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         Scanner in = new Scanner(System.in);
  5.         String[] question=in.nextLine().split(",");
  6.         String[] answer=in.nextLine().split(",");
  7.         
  8.         List<String> resList=new ArrayList<>();
  9.         for(int i=0;i<question.length;i++){
  10.             String q=question[i];
  11.             boolean isFound=false;
  12.             for(int j=0;j<answer.length;j++){
  13.                 String a=answer[j];
  14.                 if(change(q,a)){
  15.                     resList.add(a);
  16.                     isFound=true;
  17.                 }else if(dist(q,a)){
  18.                     resList.add(a);
  19.                     isFound=true;
  20.                 }
  21.             }
  22.             if(!isFound){
  23.                 resList.add("not found");
  24.             }
  25.         }
  26.             String res= "";
  27.             for(int i=0;i<resList.size();i++){
  28.                 res+=resList.get(i)+",";
  29.             }
  30.             System.out.println(res.substring(0,res.length()-1));
  31.         }
  32.     public static boolean dist(String question,String answer){
  33.         List<Character> qList=new ArrayList<>();
  34.         for(int i=0;i<question.length();i++){
  35.             char c=question.charAt(i);
  36.             if(!qList.contains(c)){
  37.                 qList.add(c);
  38.             }
  39.         }
  40.         List<Character> aList=new ArrayList<>();
  41.         for(int i=0;i<answer.length();i++){
  42.             char c=answer.charAt(i);
  43.             if(!aList.contains(c)){
  44.                 aList.add(c);
  45.             }
  46.         }
  47.         if(qList.equals(aList)){
  48.             return true;
  49.         }
  50.         return false;
  51.         
  52.     }
  53.     public static boolean change(String question,String answer){
  54.         String[] qStr=question.split("");
  55.         Arrays.sort(qStr);
  56.         String[] aStr=answer.split("");
  57.         Arrays.sort(aStr);
  58.         if(Arrays.equals(qStr,aStr)){
  59.             return true;
  60.         }
  61.         return false;
  62.     }
  63. }

2 木板

题目链接: 

【满分】【华为OD机试真题2023 JAVA&JS】木板_若博豆的博客-CSDN博客

java代码(博客里的):

  1. public class Main{
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         Scanner sc = new Scanner(System.in);
  6.  
  7.         int n = sc.nextInt();
  8.         int m = sc.nextInt();
  9.  
  10.         int[] nums = new int[n];
  11.         for(int i=0; i<n; i++){
  12.             nums[i] = sc.nextInt();
  13.         }
  14.  
  15.         Arrays.sort(nums);
  16.  
  17.         while (m>0){
  18.             m--;    //木材一段一段的截
  19.             for(int i=1; i<n; i++){
  20.                 if(nums[i] > nums[i-1]){
  21.                     nums[i-1] ++;   //碰到比后面的短的就加一截
  22.                     break;
  23.                 }
  24.                 if(i == n-1){
  25.                     nums[i] ++; //所有木材一样长则在最后一根加一截
  26.                 }
  27.             }
  28.         }
  29.  
  30.         System.out.println(nums[0]);
  31.     }
  32. }

c++代码:

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5.  
  6. const int N = 100010;
  7.  
  8. int n, m;
  9. int a[N];
  10.  
  11. int main()
  12. {
  13.     scanf("%d%d", &n, &m);
  14.     
  15.     int min = 0;
  16.     
  17.     for(int i = 0; i < n; i ++ ) 
  18.         scanf("%d", &a[i]);
  19.     
  20.     sort(a , a + n);//从小到大排序
  21.     
  22.     while(m -- ) {
  23.         for(int i = 1; i < n; i ++ ) {
  24.             if(a[i] > a[i - 1])//如果比前一个长, 前一个+1
  25.             {
  26.                 a[i - 1] ++ ;//
  27.                 break;
  28.             }//否则 不加
  29.             if(i == n - 1)//遍历到尾巴了, 就最后一节+1
  30.             {
  31.                 a[i] ++ ;
  32.             }
  33.         }
  34.         
  35.     }
  36.     
  37.     cout << a[0] << endl;
  38.     
  39.     return 0;
  40. }

3 查找重复代码

题目链接:

java(博客里的)

  1. import java.util.Scanner;
  2.  
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         String str1 = sc.nextLine();
  7.         String str2 = sc.nextLine();
  8.         String result = "";
  9.         int start = 0;
  10.         int end = 1;
  11.         while(end <= str2.length()){
  12.             String subStr = str2.substring(start,end);
  13.             if (str1.contains(subStr)){
  14.                 result = subStr;
  15.             }else {
  16.                 start++;
  17.             }
  18.             end++;
  19.         }
  20.         System.out.println(result);
  21.     }
  22. }

c++代码:

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.     string a;//0-200 暴力枚举
  8.     string b;
  9.     getline(cin, a);
  10.     getline(cin, b);
  11.     
  12.     int len1 = a.length();
  13.     int len2 = b.length();
  14.     if(len1 > len2) swap(a, b);//让a是短的
  15.     
  16.     string res = "";
  17.     
  18.     //双指针 [i,j] 判断 n * n = 10000
  19.     for(int j = len1 - 1; j > 0; j -- )
  20.     {
  21.         for(int i = 0; i < j; i ++ )
  22.         {
  23.             string temp = a.substr(i, j - i + 1);
  24.             if(b.find(temp) != -1) {
  25.                 if(temp.length() > res.length())
  26.                 res = temp;
  27.             }
  28.         }
  29.     }
  30.     
  31.     cout << res << endl;
  32.     
  33.     return 0;
  34. }

5 单词倒序

java代码(博客里的)

  1.  
  2. import java.util.Scanner;
  3.  
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner scanner = new Scanner(System.in);
  7.         String str = scanner.nextLine();
  8.         String result = "";
  9.         int start = 0;
  10.         for (int i = 0; i< str.length(); i++) {
  11.             char a = str.charAt(i);
  12.             if (a==' ' || a=='?' || a=='.' || a==',') {
  13.                 if (i > start) {
  14.                     StringBuilder word = new StringBuilder(str.substring(start, i));
  15.                     result = result + word.reverse() + a;
  16.                 } else {
  17.                     result = result + a;
  18.                 }
  19.                 start = i + 1;
  20.             } else if (i == str.length() -1) {
  21.                     StringBuilder word = new StringBuilder(str.substring(start, i + 1));
  22.                     result = result + word.reverse();
  23.                 }
  24.         }
  25.         System.out.println(result);
  26.     }
  27. }

c++代码:

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.     string a[100];
  8.     int i = 0;
  9.     while(cin >> a[i]) i ++;
  10.     for(int j = 0; j < i; j ++ )
  11.     {
  12.         //取出字符串数组中的每个字符串a[i]
  13.         string str = a[j];
  14.         char temp = '\0';
  15.         for(int k = str.length() - 1; k >= 0; k -- )
  16.         {
  17.             //反转后将字符串中的每个字符输出
  18.             //如果是标点, 先不输出
  19.             if(str[k] == ',' || str[k] == '.' || str[k] == '!') {
  20.                 temp = str[k];
  21.             }
  22.             else cout << str[k];
  23.         }
  24.         if(temp != '\0') cout << temp;
  25.         cout << ' ';
  26.         temp = '\0';
  27.     }
  28.     
  29.     cout << endl;
  30.     
  31.     return 0;
  32. }

6 打印文件

java代码(博客里的)

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Scanner;
  4.  
  5. public class Main {
  6.     public static void main(String[] args) {
  7.         List<List<File>> m = new ArrayList<>();
  8.         for (int i = 0; i < 5; i++) {
  9.             m.add(new ArrayList<>());
  10.         }
  11.         Scanner in = new Scanner(System.in);
  12.         int n = in.nextInt();
  13.         int flag = 0;
  14.         for (int i = 0; i <= n; i++) {
  15.             String s = in.nextLine();
  16.             String[] s1 = s.split(" ");
  17.             String type = s1[0];
  18.  
  19.             if ("IN".equals(type)) {
  20.                 int p = Integer.parseInt(s1[1]);
  21.                 int num = Integer.parseInt(s1[2]);
  22.                 flag++;
  23.                 File file = new File(flag, num);
  24.                 List<File> files = m.get(p - 1);
  25.                 files.add(file);
  26.             } else if ("OUT".equals(type)) {
  27.                 int p = Integer.parseInt(s1[1]);
  28.                 List<File> files = m.get(p - 1);
  29.                 if (files != null && files.size() > 0) {
  30.                     files.sort((a, b) -> {
  31.                         return b.getWeight() - a.getWeight();
  32.                     });
  33.                     File file = files.get(0);
  34.                     System.out.println(file.getIndex());
  35.                     files.remove(0);
  36.                 } else {
  37.                     System.out.println("NULL");
  38.                 }
  39.             }
  40.  
  41.         }
  42.  
  43.  
  44.     }
  45. }
  46.  
  47. class File {
  48.     private int index;
  49.     private int weight;
  50.  
  51.     public File(int index, int weight) {
  52.         this.index = index;
  53.         this.weight = weight;
  54.     }
  55.  
  56.     public int getIndex() {
  57.         return index;
  58.     }
  59.  
  60.     public void setIndex(int index) {
  61.         this.index = index;
  62.     }
  63.  
  64.     public int getWeight() {
  65.         return weight;
  66.     }
  67.  
  68.     public void setWeight(int weight) {
  69.         this.weight = weight;
  70.     }
  71. }

c++代码: 

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. #define x first
  5. #define y second
  6.  
  7. using namespace std;
  8.  
  9. const int N = 1010;
  10. typedef pair<int, pair<int, int>> PII;
  11.  
  12. int m;
  13. vector<PII> alls;
  14.  
  15. int main()
  16. {
  17.     scanf("%d", &m);
  18.     int count = 1;//文件的编号
  19.     
  20.     while(m -- ) {
  21.         string op;
  22.         
  23.         cin >> op;
  24.         int p, n;
  25.         bool flag = false;
  26.         
  27.         if(op == "IN") 
  28.         {
  29.             scanf("%d%d", &p, &n);//打印机编号p, 优先级n
  30.             alls.push_back({n, {count, p}});
  31.             count ++ ;
  32.             
  33.             //sort(alls.rbegin(), alls.rend());//按照n排序
  34.             sort(alls.rbegin(), alls.rend(), [](const PII &a, const PII &b){
  35.                 return a.x < b.x; // 先按照优先级n降序, 再按照插入顺序count升序
  36.             });
  37.             
  38.             // for(auto e : alls) 
  39.             // {
  40.             //     cout << e.x << ' '<< e.y.x << ' ' << e.y.y << endl;
  41.             // } cout << endl;
  42.         } 
  43.         else if(op == "OUT")
  44.         {
  45.             scanf("%d", &p);
  46.             
  47.             int len = alls.size();
  48.             //遍历输出结果
  49.             for(int i = 0; i < len; i ++ ) 
  50.             {
  51.                 //如果有结果 输出结果, 在数组中删除该数 flag=true, 退出循环
  52.                 if(alls[i].y.y == p) 
  53.                 {
  54.                     cout << alls[i].y.x << endl;
  55.                     auto iter = alls.erase(alls.begin() + i);//删除元素
  56.  
  57.                     flag = true;
  58.                     break;
  59.                 } 
  60.             }
  61.             //如果遍历完都没有结果, flag还是false 输出NULL
  62.             if(flag == false) cout << "NULL" << endl;
  63.             flag = false;
  64.         }
  65.     }
  66.     return 0;
  67. }

7 对称字符串

c++代码, 不过这个回溯会爆内存 报memory limit exceeded 或者 time limit exceeded

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int N = 100010;
  6.  
  7. int t, n, k;
  8.  
  9. string solve(int x) {//每次就是把前一个的字符串取反 + 原字符串
  10.     if(x == 1) return "R";//1输出R
  11.     
  12.     string str = solve(x - 1);
  13.     
  14.     string res = "";
  15.     for(int i = 0; i < str.length(); i ++ ) {
  16.         if(str[i] == 'R') res += 'B';
  17.         else if(str[i] == 'B') res += 'R';
  18.     }
  19.     
  20.     return res + str; //翻转结果 + 原字符串
  21. }
  22.  
  23. int main()
  24. {
  25.     scanf("%d", &t);
  26.     
  27.     while(t -- ) {
  28.         scanf("%d%d", &n, &k);
  29.         string ans = solve(n);//只能在25以内, 否则memory limit exceeded
  30.         if(ans[k] == 'R') cout << "red" << endl;
  31.         else cout << "blue" << endl;
  32.     }
  33.     
  34.     return 0;
  35. }

 c++ 找规律写法: 这个是扒的博客java解法

  1. #include <iostream>
  2. #include <cmath>
  3. #include <algorithm>
  4.  
  5. typedef long long ll;
  6. using namespace std;
  7.  
  8. int t, n, k;//n是第几个字符串, k是字符的位置
  9.  
  10. int solve(ll len, ll k, int rev) //len是字符串的长度, k是位置, rev是翻转次数
  11. {
  12.     if(len == 1) return rev;//回溯到最底层 就返回现在的rev就是翻转的次数
  13.     
  14.     ll half = len / 2;//长度的一半
  15.     if(k < half) { //k在前半部分, 是反转后的部分
  16.         rev ++ ;//翻转次数++
  17.         return solve(half, k, rev);
  18.     } else {//后半部分
  19.         return solve(half, k - half, rev);
  20.     }
  21. }
  22.  
  23. int main()
  24. {
  25.     scanf("%d", &t);
  26.     
  27.     while(t -- ) {
  28.         scanf("%d%d", &n, &k);
  29.         //长度
  30.         ll len = (ll)pow(2, n - 1);
  31.         //cout << len << endl;
  32.         
  33.         int ans = solve(len, k, 0);//传入长度, 位置, 求该位置的翻转次数
  34.         //原字符是R 翻转偶数次就是R 翻转奇数次就是B
  35.         if(ans % 2) cout << "blue" << endl;//奇数次
  36.         else cout << "red" << endl;//偶数次
  37.         
  38.     }
  39.     
  40.     return 0;
  41. }

java代码(博客)

  1. public class Main{
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         Scanner sc = new Scanner(System.in);
  6.  
  7.         int T = sc.nextInt();
  8.  
  9.         for(int i=0; i<T; i++){
  10.             int n = sc.nextInt();
  11.             long k = sc.nextLong();
  12.  
  13.             long charNum = (long) Math.pow(2, n - 1);       //第n行的总字符个数
  14.             int re = doProcess(charNum, k, 0);
  15.             if (re % 2 == 0) {
  16.                 System.out.println("red");      //翻转次数为2的倍数
  17.             } else {
  18.                 System.out.println("blue");
  19.             }
  20.         }
  21.  
  22.     }
  23.  
  24.     /**
  25.      * 翻转次数
  26.      * @param count     总字符的个数
  27.      * @param cur       字符的索引
  28.      * @param reverse       翻转次数
  29.      * @return
  30.      */
  31.     public static int doProcess(long count, long cur, int reverse){
  32.  
  33.         if (count == 1) {
  34.             return reverse;
  35.         }
  36.         long half = count / 2;
  37.         if (cur < half) {    //小于半数说明是经过翻转的部分
  38.             reverse ++;
  39.             return doProcess(half, cur, reverse);
  40.         } else {
  41.             return doProcess(half, cur - half, reverse);
  42.         }
  43.     }
  44.  
  45. }

8 分界线

爷的c++代码, 纯打暴力

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5.  
  6. const int N = 110;
  7.  
  8. string aa[N], bb[N];
  9.  
  10. int main()
  11. {
  12.     string a;//报纸内容
  13.     string b;//是否可以拼成的 匿名信
  14.     
  15.     getline(cin, a);
  16.     getline(cin, b);
  17.     
  18.     string res = "";
  19.     int j = 0;
  20.     for(int i = 0; i < a.length(); i ++ ) //100 * 104 = 100400
  21.     {
  22.         if(a[i] == ' ') {
  23.             aa[j ++ ] = res;
  24.             res = "";
  25.         } else res += a[i];
  26.     } aa[j ++ ] = res;
  27.     //存进去了aa[N] 报文的字符串数组
  28.     int len_a = j;
  29.     
  30.     res = "";
  31.     j = 0;
  32.     for(int i = 0; i < b.length(); i ++ ) //100400
  33.     {
  34.         if(b[i] == ' ') {
  35.             bb[j ++ ] = res;
  36.             res = "";
  37.         } else res += b[i];
  38.     } bb[j ++ ] = res;
  39.     //存进去了bb[N] 报文的字符串数组
  40.     int len_b = j;
  41.     
  42.     int count = 0;
  43.     for(int i = 0; i < len_b; i ++ ) {//枚举每个匿名信单词
  44.         string ano = bb[i];
  45.         sort(ano.begin(), ano.end());
  46.         for(int j = 0; j < len_a; j ++ ) {//枚举原报文遍历单词
  47.             string news = aa[j];
  48.             sort(news.begin(), news.end());
  49.             if(ano == news) {
  50.                 count ++ ;
  51.                 break;//结束报文的遍历
  52.             } 
  53.         }
  54.     }
  55.     if(count == len_b) cout << "true" << endl;
  56.     else cout << "false" << endl;
  57.     
  58.     return 0;
  59. }

java(博客里的)

  1. import java.util.Arrays;
  2. import java.util.Scanner;
  3.  
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc  = new Scanner(System.in);
  7.         String newsapper = sc.nextLine();
  8.         String anonymousLetter = sc.nextLine();
  9.         String[] newsapperArr = newsapper.split(" ");
  10.         String[] anonymousLetterArr = anonymousLetter.split(" ");
  11.         for (int i = 0; i < anonymousLetterArr.length; i++) {
  12.             String ii = anonymousLetterArr[i];
  13.             char[] ic = ii.toCharArray();
  14.             Arrays.sort(ic);
  15.             boolean flag = false;
  16.             for (int j = 0; j < newsapperArr.length; j++) {
  17.                 String jj = newsapperArr[j];
  18.                 char[] jc = jj.toCharArray();
  19.                 Arrays.sort(jc);
  20.                 if (Arrays.equals(ic, jc)){
  21.                     flag = true;
  22.                     break;
  23.                 }
  24.             }
  25.             if (!flag){
  26.                 System.out.println(false);
  27.                 System.exit(0);
  28.             }
  29.         }
  30.         System.out.println(true);
  31.     }
  32. }

9 关联端口组合并

string数组转成int数组的方法: 

String数组转int数组_躺平的菜鸟啊的博客-CSDN博客

不需要像c++那样遍历了哈哈哈,  java也不错嘛

java代码(博客里的思路) 我打了备注, 改动了一点:

  1. import java.util.*;
  2.  
  3. public class Main{
  4.     public static void main(String[] args){
  5.         
  6.         Scanner myScanner = new Scanner(System.in);
  7.         
  8.         //二维数组, 外层用list保存, 内层用set集合保存, set集合有去重和排序的功能,
  9.         //每输入一个组合, 对list进行遍历, 找出其中有两个并集的集合进行合并
  10.         
  11.         int m = myScanner.nextInt();
  12.         
  13.         if(m > 10) System.out.println("[[]]");
  14.         else {
  15.             List<Set<Integer>> list = new ArrayList<>();
  16.             //myScanner.nextLine();//读取行
  17.             
  18.             //循环
  19.             for(int i = 0; i < m; i ++ ) {
  20.                 String[] strings = myScanner.nextLine().split(",");//读取行 分成zi字符串数组strings
  21.                 int[] nums = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();//转换成字符串数组nums
  22.                 
  23.                 Set<Integer> set = new TreeSet<>();
  24.                 
  25.                 if(nums.length == 1 ) {//只有一个元素, 直接添加
  26.                     set.add(nums[0]);
  27.                     list.add(set);//加入list
  28.                 } else {
  29.                     for(int num : nums) {
  30.                         set.add(num);//数字加到set集合中
  31.                     }
  32.                     list.add(set);//这个新的set加到list, 默认加到最后
  33.                     merge(set, list, list.size() - 1 );//看是否需要合并set和list内的set
  34.                 }
  35.             }
  36.             
  37.             System.out.println(list);//输出结果
  38.         }
  39.         
  40.         
  41.     }
  42.     
  43.     public static void merge(Set<Integer> set, List<Set<Integer>> list, int index) {
  44.         for(int i = 0; i < list.size(); i ++ ) {//遍历list中的每个set 
  45.             if(i == index) continue;//如果是相同 就不继续了
  46.         
  47.             Set<Integer> setIdx = list.get(i);//当前索引的set集合
  48.             
  49.             Set<Integer> setTemp = new TreeSet<>();
  50.             setTemp.addAll(set);//临时集合 保存交集 
  51.             
  52.             setTemp.retainAll(setIdx);//待判断的set和当前的setIdx的交集, 返回交集
  53.             
  54.             if(setTemp.size() >= 2) {//当交集>=2 则需要合并
  55.             
  56.                 set.addAll(setIdx); //把新传入的set与setIdx合并
  57.                 
  58.                 list.remove(i);//两个都移除后
  59.                 list.remove(index);
  60.                 
  61.                 int st = i < index ? i : index;//存靠前的下标
  62.                 list.add(st, set);//加上并集set 在st位置 
  63.                 
  64.                 merge(set, list, st);//新建的组合再进行判断合并, 因为合并之后
  65.             }
  66.         }
  67.     }
  68. }

10 货币单位换算

c++代码, 按照博客思路写的

  1. #include <iostream>
  2. #include <cmath>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. int n;
  8.  
  9. double solve(string str, char c) {
  10.     
  11.     double res;
  12.     for(int i = 0; i < str.length(); i ++ ) {
  13.         res *= 10;
  14.         res += str[i] - '0';
  15.     }
  16.     
  17.     if(c == 'C') res *= 100;
  18.     else if(c == 'J') res *= (double) 10000 / 1825;
  19.     else if(c == 'H') res *= (double) 10000 / 123;
  20.     else if(c == 'E') res *= (double) 10000 / 14;
  21.     else if(c == 'G') res *= (double) 10000 / 12;
  22.             
  23.     else if(c == 'f') res *= 1;
  24.     else if(c == 's') res *= (double) 100 / 1825;
  25.     else if(c == 'c') res *= (double) 100 / 123;
  26.     else if(c == 'e') res *= (double) 100 / 14;
  27.     else if(c == 'p') res *= (double) 100 / 12;
  28.     
  29.     return res;
  30. }
  31.  
  32. int main(){
  33.     
  34.     scanf("%d", &n);
  35.     double res = 0;
  36.     
  37.     while(n -- ) {
  38.         string str;
  39.         cin >> str;
  40.         
  41.         string tmp;
  42.         
  43.         for(int i = 0; i < str.length(); i ++ ) {
  44.             char c = str[i];
  45.             if(c >= '0' && c <= '9') tmp += str[i];
  46.             else {
  47.                 res += solve(tmp, c);
  48.                 
  49.                 i += 2;
  50.                 if(c == 'c') i += 2;
  51.                 else if(c == 'e') i += 8;
  52.                 else if(c == 'p') i += 2;
  53.                 
  54.                 tmp = "";//重来
  55.             }
  56.         }
  57.     }
  58.     
  59.     cout << floor(res) << endl;
  60.     return 0;
  61. }

java代码(博客中的)

  1. import java.util.Scanner;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.         double money = 0.0;
  8.         int count = Integer.parseInt(sc.nextLine());
  9.         for (int i = 0; i < count; i++) {
  10.             String line = sc.nextLine();
  11.             String[] split = line.split("\\d");
  12.             for (String type : split) {
  13.                 if(!type.isEmpty()){
  14.                     String num = line.substring(0, line.indexOf(type));
  15.                     money += getCny(type, Double.parseDouble(num));
  16.                     line = line.substring(line.indexOf(type) + type.length());
  17.                 }
  18.             }
  19.         }
  20.         System.out.println(Math.round(Math.floor(money)));
  21.     }
  22.  
  23.     private static double getCny(String type, double num) {
  24.         switch (type) {
  25.             case "CNY":
  26.                 return num * 100;
  27.             case "fen":
  28.                 return num;
  29.             case "JPY":
  30.                 return num / 1825 * 10000;
  31.             case "sen":
  32.                 return num / 1825 * 100;
  33.             case "HKD":
  34.                 return num / 123 * 10000;
  35.             case "cents":
  36.                 return num / 123 * 100;
  37.             case "EUR":
  38.                 return num / 14 * 10000;
  39.             case "eurocents":
  40.                 return num / 14 * 100;
  41.             case "GBP":
  42.                 return num / 12 * 10000;
  43.             case "pence":
  44.                 return num / 12 * 100;
  45.         }
  46.         return 0;
  47.     }
  48.  
  49. }

11 获得完美走位

java代码(博客中的, 我打了备注)

  1. import java.util.*;
  2.  
  3. public class Main{
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.         String str = sc.nextLine();
  8.  
  9.         int strLen = str.length();
  10.         int count = strLen / 4;
  11.         Map<Character, Integer> map = new HashMap<>();
  12.         
  13.         //把字符串中所有的字符存到map中, k-v表示字符-个数
  14.         for(int i = 0; i < strLen; i++)
  15.         {
  16.             char c = str.charAt(i);
  17.             if(map.containsKey(c)) map.put( c, map.get(c) + 1);//保存k-v 字符-个数+1
  18.             else map.put( c, 1 - count);//字符-需要的个数(用负数表示, 最后才能归0)
  19.         }//比如AASW 就是 [A,1] [S,0] [W,0]  
  20.  
  21.         int min = str.length();
  22.         
  23.         for (int i = 0; i < strLen; i++) {
  24.             HashMap<Character, Integer> copy = new HashMap<>(map);
  25.             int res = 0;
  26.             
  27.             if (copy.get(str.charAt(i)) > 0) //如果某个方向多走了
  28.             {
  29.                 for (int j = i; j < str.length(); j++) //往后遍历其他的
  30.                 {
  31.                     char c = str.charAt(j);
  32.                     copy.put(c, copy.get(c) - 1);//把他变换一下
  33.                     res ++ ;//答案++
  34.                     if (isZero(copy)) break;//判断是否都是0
  35.                 }
  36.             }
  37.             if (isZero(copy)) res = Math.min(min, res);
  38.         }
  39.  
  40.         System.out.println(res);
  41.     }
  42.  
  43.     private static boolean isZero(HashMap<Character, Integer> copy) {
  44.         Collection<Integer> values = copy.values();
  45.         for (Integer value : values) {
  46.             if (value > 0) return false;
  47.         }
  48.         return true;
  49.     }
  50. }

12 简单的自动曝光

忽然发现我自己做的题, 不一定会满分哈哈 因为都只测了一两个用例

c++代码: 这个很简单

  1. #include <iostream>
  2. #include <cmath>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 110;
  8.  
  9. int a[N];
  10.  
  11. int main(){
  12.     
  13.     int sum = 0;
  14.     
  15.     int i = 0;
  16.     while(cin >> a[i]) {
  17.         sum += a[i]; 
  18.         i ++ ;
  19.     }
  20.     
  21.     double res = (double)(512 - sum) / 4;
  22.     
  23.     cout << floor(res) << endl;//向下取整 1 2
  24.     
  25.     return 0;
  26. }

参考一下java的满分答案, 博客里面的: 

  1. import java.util.*;
  2. import java.util.Arrays;
  3. import java.util.Map;
  4. import java.util.HashMap;
  5. import java.util.stream.Stream;
  6.  
  7. public class Main{
  8.  
  9.     public static void main(String[] args) {
  10.         Scanner in = new Scanner(System.in);
  11.  
  12.         String[] strings = in.nextLine().split(" ");
  13.         int[] nums = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();
  14.  
  15.         solution(nums);
  16.     }
  17.  
  18.     public static void solution(int[] list) {
  19.         int ans = 0;
  20.         int t = Integer.MAX_VALUE;
  21.         for (int i = -127; i < 255; ++i) {
  22.             int sum = 0;
  23.             for (int j = 0; j < list.length; ++j) {
  24.                 int tmp = i + list[j];
  25.                 if (tmp < 0) {
  26.                     tmp = 0;
  27.                 } else if (tmp > 255) {
  28.                     tmp = 255;
  29.                 }
  30.                 sum += tmp;
  31.             }
  32.             if (t > Math.abs(128 * list.length - sum)) {
  33.                 ans = i;
  34.                 t = Math.abs(128 * list.length - sum);
  35.             }
  36.         }
  37.         System.out.println(ans);
  38.     }
  39.  
  40. }

13 日志采集系统

c++ 代码, 我觉得我写的很牛哈哈哈

  1. #include <iostream>
  2. #include <cmath>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 1010;//最多1000个 每个里面100条
  8.  
  9. int a[N], s[N], m[N];//
  10.  
  11. int main(){
  12.     
  13.     int i = 1;
  14.     while(cin >> a[i]) {
  15.         
  16.         s[i] = s[i - 1] + a[i];//前缀和
  17.         m[i] = s[i - 1] + s[i];//要减去的
  18.         //cout << s[i] << ' ' <<m[i] << endl;
  19.         i ++ ;
  20.     }
  21.     int n = i;//总采集次数
  22.     
  23.     int res = 0;
  24.     int score = 0;
  25.     for(int i = 1; i <= n; i ++ ) 
  26.     {
  27.         score = min(100, s[i]) - m[i - 1];
  28.         
  29.         res = max(res, score);
  30.         
  31.         if(s[i] >= 100) break;
  32.     }
  33.     
  34.     cout << res <<endl;
  35.     return 0;
  36. }

java代码:

就不放了 没我写得好

14 数组的中心位置

c++ 简洁优雅, 不过可能会爆int 需要优化一下

  1. #include <iostream>
  2. #include <cmath>
  3. #include <algorithm>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 1034;//最多1024个
  8.  
  9. int a[N], s[N];
  10.  
  11. int main(){
  12.     
  13.     int i = 1;
  14.     s[0] = 1;
  15.     while(cin >> a[i]) {
  16.         s[i] = s[i - 1] * a[i];
  17.         i ++ ;
  18.     }
  19.     int n = i - 1;
  20.     
  21.     for(int j = 1; j <= n; j ++ ) {
  22.         if(s[j] * s[j + 1] == s[n]) {
  23.             cout << j << endl;
  24.             return 0;
  25.         }
  26.     }
  27.         
  28.     cout << "-1" << endl;    
  29.     return 0;
  30. }

优化:

看一下java解法 博客写的, 没动过:

  1. public class Main{
  2.  
  3.     public static void main(String[] args) {
  4.  
  5.         Scanner sc = new Scanner(System.in);
  6.         String[] strings = sc.nextLine().split(" ");
  7.         int len = strings.length;
  8.         int[] nums = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();
  9.  
  10.         //题目说：数组第一个元素的左侧积为1，最后一个元素的右侧积为1
  11.         int left=1, right=1;
  12.         for(int num : nums){
  13.             right = right * num;    //数组的总乘积
  14.         }
  15.  
  16.         boolean flag =false;
  17.         for(int i=0; i<len; i++){
  18.             if(i!=0){
  19.                 left = left * nums[i-1];    //左侧积做乘法
  20.             }
  21.             right = right / nums[i];    //右侧积做除法
  22.             if(left == right){
  23.                 System.out.print(i);
  24.                 flag = true;
  25.                 break;
  26.             }
  27.         }
  28.         if(!flag){
  29.             System.out.println(-1);
  30.         }
  31.     }
  32.  
  33. }

15 通信误码

java代码: 按照博客思路打的

  1. import java.util.*;
  2.  
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         
  7.         int n = sc.nextInt();
  8.         
  9.         int[] nums = new int[n];
  10.         
  11.         for(int i = 0; i < n; i ++ ) {
  12.             nums[i] = sc.nextInt();
  13.         }
  14.         
  15.         Map<Integer, Integer> map = new HashMap<>();//存k-v 误码-误码频率
  16.         int max = 0;//数字出现的最大次数
  17.         
  18.         for(int i = 0; i < n; i ++ ) {
  19.             int count = map.getOrDefault(nums[i], 0) + 1;//当前数字出现次数再加上1次
  20.             max = Math.max(max, count);//取最大值
  21.             map.put(nums[i], count);//存进map
  22.         }
  23.         
  24.         Set<Integer> set = new HashSet<>();//存最高误码的集合
  25.         for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
  26.             if(entry.getValue() == max) {
  27.                 set.add(entry.getKey());//加入频率最高的数字
  28.             }
  29.         }
  30.         
  31.         int res = n;
  32.         for(Integer integer : set) {//双指针 取出某个max值, 
  33.             int l = 0, r = n - 1;
  34.             while(nums[l] != integer) l ++ ;//当两个指针都是max值的时候才停下
  35.             while(nums[r] != integer) r -- ;
  36.             if(l <= r) res = Math.min(res, r - l + 1);//max取结果
  37.         }
  38.         
  39.         System.out.println(res);
  40.     }
  41. }

getOrDefault方法: 

格式：
Map.getOrDefault(key，默认值)；

Map中会存储一一对应的key和value。
如果 在Map中存在key，则返回key所对应的的value。
如果 在Map中不存在key，则返回默认值。

entrySet()

Java中Map的 entrySet() 详解以及用法(四种遍历map的方式)-CSDN博客

【java笔记】java中的Map.Entry和Map.entrySet()方法的使用_map.entry<integer,integer> entry:map.entryset()_棉花糖灬的博客-CSDN博客

Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value (我们总说键值对键值对, 每一个键值对也就是一个Entry)
Map.Entry里面包含getKey()和getValue()方法

entrySet是java中 键-值对的集合，Set里面的类型是Map.Entry，一般可以通过map.entrySet()得到。

  • entrySet实现了Set接口，里面存放的是键值对。一个K对应一个V。

即通过getKey（）得到K，getValue得到V。

这种遍历方法比较快: 

Map.Entry<Integer, Integer> entry : map.entrySet()

16 网上商城优惠

【华为OD机试真题2023 JAVA】网上商城优惠活动（一）_接口测试主要测哪些方面_若博豆的博客-CSDN博客z

这题绕糊涂了 , 没写对, 有空重新弄一下

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <cmath>
  4.  
  5. using namespace std;
  6.  
  7. int mj;
  8. int dz;
  9. int wmk;
  10.  
  11. int n;
  12.  
  13. double manjian(int money) {
  14.     int a = money / 100;//可以使用的张数
  15.     int count = a > mj ? mj : a;
  16.     double res = (double) (money - count * 10) ;
  17.     return res;
  18. }
  19.  
  20. double wumenk(int money) {
  21.     int a = money / 5;//可以使用的张数
  22.     int count = a > wmk ? wmk : a;
  23.     double res = (double) (money - count * 5) ;
  24.     return res;
  25. }
  26.  
  27. int main()
  28. {
  29.     scanf("%d%d%d", &mj, &dz, &wmk);
  30.     scanf("%d", &n);
  31.     
  32.     int res;
  33.     
  34.     while(n -- ) {
  35.         
  36.         int money;
  37.         scanf("%d", &money);//账单金额 操作前
  38.         int res = 2e9;
  39.         int tmp = 2e9;
  40.         //C32 6中情况 打折只能用一次, 其他的无使用限制
  41.         
  42.         //先满减后打折
  43.         if(mj > 0 && dz > 0) {
  44.             tmp = manjian(money);
  45.             tmp = floor((double)tmp * 0.92);
  46.         } 
  47.         res = min(res, tmp);
  48.         
  49.         //先满减后无门槛
  50.         if(mj > 0 && wmk > 0) {
  51.             tmp = manjian(money);
  52.             tmp = wumenk(tmp);
  53.         }
  54.         res = min(res, tmp);
  55.         
  56.         //先打折后满减
  57.         if(dz > 0 && mj > 0) {
  58.             tmp = floor(money * 0.92);
  59.             tmp = manjian(tmp);
  60.         }
  61.         res = min(res, tmp);
  62.         
  63.         //先打折后无门槛
  64.         if(dz > 0 && wmk > 0) {
  65.             tmp = floor((double)tmp * 0.92);
  66.             tmp = wumenk(tmp);
  67.         }
  68.         res = min(res, tmp);
  69.         
  70.         //先无门槛后满减
  71.         if(mj > 0 && wmk > 0) {
  72.             tmp = wumenk(tmp);
  73.             tmp = manjian(money);
  74.         }
  75.         res = min(res, tmp);
  76.         
  77.         //先无门槛后打折
  78.         if(dz > 0 && wmk > 0) {
  79.             tmp = wumenk(tmp);
  80.             tmp = floor((double)tmp * 0.92);
  81.         }
  82.         res = min(res, tmp);
  83.         
  84.         
  85.         cout << res << endl;
  86.     }
  87.     return 0;
  88. }

java博客代码

  1. import java.util.Scanner;
  2.  
  3. public class Main{
  4.  
  5.     public static int manjian;
  6.     public static int dazhe;
  7.     public static int wumenkan;
  8.     //券的最小使用量
  9.     public static int mincountQuan;
  10.     //最少价格
  11.     public static int minCount;
  12.  
  13.     public static void main(String[] args) {
  14.  
  15.         Scanner sc = new Scanner(System.in);
  16.  
  17.         manjian = sc.nextInt();
  18.         dazhe = sc.nextInt();
  19.         wumenkan = sc.nextInt();
  20.  
  21.         int n = sc.nextInt();
  22.  
  23.         for(int i=0; i<n; i++){
  24.  
  25.             double money = sc.nextInt();
  26.  
  27.             //首先使用满减的张数
  28.             int quanMJ = money/100 > manjian ? manjian : (int) (money / 100);
  29.  
  30.             //使用无门槛的券的张数
  31.             int quanWMK;
  32.             //券的最小使用量
  33.             mincountQuan = Integer.MAX_VALUE;
  34.             //最少价格
  35.             minCount = Integer.MAX_VALUE;
  36.  
  37.             if(dazhe > 0){  //有打折券的情况
  38.  
  39.                 //先满减后打折
  40.                 int MJafterDZ = (int) Math.floor(Manjian(money) * 0.92);
  41.                 flush( MJafterDZ, quanMJ + 1);
  42.  
  43.                 //先打折后满减
  44.                 int DZafterMJ = (int) Math.floor(Manjian(money * 0.92));
  45.                 //先打折后满减的满减券
  46.                 int quanDZafterMJ = (int) (money * 0.92 / 100 > manjian ? manjian : money * 0.92 / 100);
  47.                 flush( DZafterMJ, quanDZafterMJ + 1);
  48.  
  49.                 //先打折后无门槛
  50.                 double dazhe = money * 0.92;
  51.                 //无门槛需要的张数
  52.                 quanWMK = wumenkan(dazhe);
  53.                 int dazheWMK;
  54.                 if(dazhe <= quanWMK * 5){
  55.                     //打折后的价格小于等于无门槛的全部价格（可以0元购）
  56.                     dazheWMK = 0;
  57.                 }else {
  58.                     dazheWMK = (int) Math.floor(dazhe - quanWMK * 5);
  59.                 }
  60.                 flush( dazheWMK, quanWMK + 1);
  61.  
  62.                 //先无门槛后打折
  63.                 int wmkDZ;
  64.                 //无门槛需要的张数
  65.                 quanWMK = wumenkan(money);
  66.                 if(money <= quanWMK * 5 ){
  67.                     //价格小于等于无门槛的全部价格（可以0元购）
  68.                     flush( 0, quanWMK);
  69.                 }else {
  70.                     wmkDZ = (int) Math.floor((money - quanWMK * 5) * 0.92);
  71.                     flush( wmkDZ, quanWMK + 1);
  72.                 }
  73.             }
  74.  
  75.             //先满减后无门槛
  76.             int mjWMK;
  77.             double manjian= Manjian(money);
  78.             //无门槛需要的张数
  79.             quanWMK =  wumenkan(manjian);
  80.             if(manjian <= quanWMK * 5){
  81.                 //满减后的价格小于等于无门槛的全部价格（可以0元购）
  82.                 mjWMK = 0;
  83.             }else {
  84.                 mjWMK = (int) Math.floor(manjian - quanWMK * 5);
  85.             }
  86.             flush( mjWMK, quanWMK + quanMJ);
  87.  
  88.             System.out.println(minCount + " " + mincountQuan);
  89.  
  90.         }
  91.     }
  92.  
  93.     /**
  94.      * 刷新最少价格和最少使用券
  95.      * @param count
  96.      * @param quanCount
  97.      */
  98.     public static void flush(int count, int quanCount){
  99.         if(count < minCount){
  100.             minCount = count;
  101.             mincountQuan = quanCount;
  102.         }else if(count == minCount){
  103.             mincountQuan = Math.min( quanCount, mincountQuan);
  104.         }
  105.     }
  106.  
  107.     /**
  108.      * 求出需要无门槛优惠券的张数
  109.      * @param money
  110.      * @return
  111.      */
  112.     public static int wumenkan(double money){
  113.  
  114.         for(int i=1; i<=wumenkan; i++){
  115.             if(money <= 5 * i) {
  116.                 return i;
  117.             }
  118.         }
  119.  
  120.         return wumenkan;
  121.     }
  122.  
  123.     /**
  124.      * 满减后的价格
  125.      * @param money
  126.      * @return
  127.      */
  128.     public static double Manjian(double money){
  129.  
  130.         if(money/100 >= manjian){
  131.             return money - manjian*10;
  132.         }else {
  133.             return money - ((int) money/100)*10;
  134.         }
  135.     }
  136.  
  137. }

17 开心消消乐

java代码

感觉这个没有回溯啊 就是找到第一个点来计算的.. 有空看吧 先记住了

  1. import java.util.Scanner;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner scanner = new Scanner(System.in);
  7.         
  8.         int row = scanner.nextInt();
  9.         int column = scanner.nextInt();
  10.         
  11.         int[][] numbers = new int[row][column];
  12.         
  13.         scanner.nextLine();
  14.         
  15.         for (int i = 0; i < row; i++) {//每行
  16.             for (int j = 0; j < column; j++) {
  17.                 numbers[i][j] = scanner.nextInt();
  18.             }
  19.         }
  20.  
  21.         int count = 0;
  22.         for (int i = 0; i < row; i++) {
  23.             for (int j = 0; j < column; j++) {
  24.                 if (numbers[i][j] == 1) {//如果该点值为1 点击一下, 再继续循环其他的点
  25.                     turnZero(numbers, row, column, i, j);
  26.                     count++;
  27.                 }
  28.             }
  29.         }
  30.  
  31.         System.out.println(count);
  32.     }
  33.  
  34.     private static void turnZero(int[][] numbers, int row, int col, int x, int y) {
  35.         numbers[x][y] = 0;//点击为0
  36.         for (int i = x - 1; i <= x + 1; i ++ ) {
  37.             for (int j = y - 1; j <= y + 1; j ++ ) {//遍历相邻的8个点
  38.                 if (i >= 0 && i < row && j >= 0 && j < col && numbers[i][j] == 1) {//如果是1
  39.                     turnZero(numbers, row, col, i, j);//就自动变为0
  40.                 }
  41.             }
  42.         }
  43.     }
  44.     
  45.     
  46. }

18 获取最大软件版本号

compareTo 复习一下

java中compareTo方法的使用_compareto在java中的用法_高某123的博客-CSDN博客

 java代码: 

  1. import java.util.*;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner scanner = new Scanner(System.in);
  7.         
  8.         String a = scanner.nextLine();
  9.         String b = scanner.nextLine();
  10.         
  11.         
  12.         String[] strs1 = a.split("\\.");//1.5.1-A 分成 1 5 1-A
  13.         String[] strs2 = b.split("\\.");
  14.         
  15.         //比较主次版本 1.3.11-S2 1.05.1 中的 1 3 和 1 05 挨个遍历这两个字符
  16.         for(int i = 0; i < 2; i ++ ) {
  17.             int va = Integer.valueOf(strs1[i]);
  18.             int vb = Integer.valueOf(strs2[i]);
  19.             
  20.             if(va != vb) {//继续遍历
  21.                 System.out.println(va > vb ? a : b);
  22.                 return;
  23.             }
  24.         }
  25.         
  26.         //增量版本可能不存在 如 直接是 1.5
  27.         //比较增量版本 和里程碑版本
  28.         if(strs1.length > 2 && strs2.length > 2 ) {//两个版本长度都 > 2
  29.             //有增量版本 就在strs[2]位置
  30.             String[] s1 = strs1[2].split("-"); //分成 1 A
  31.             String[] s2 = strs2[2].split("-");
  32.             
  33.             int va = Integer.valueOf(s1[0]);
  34.             int vb = Integer.valueOf(s2[0]);
  35.             
  36.             if(va != vb) {
  37.                 System.out.println(va > vb ? va : vb);
  38.                 return;
  39.             }
  40.             //增量版本也相同 如果都有里程碑版本
  41.             if(s1.length == 2 && s2.length == 2) {
  42.                 //字典序排序 compareTo
  43.                 System.out.println(s1[1].compareTo(s2[1]) >= 0 ? a : b);
  44.             } else {
  45.                 System.out.println(s2.length >= s2.length ? a : b);
  46.             }
  47.             
  48.         } else {
  49.             System.out.println(strs1.length >= strs2.length ? a : b);
  50.         }
  51.         
  52.     }
  53.     
  54. }

19 寻找链表的中间节点

输入:

00100 4
00000 4 -1
00100 1 12309
33218 3 00000
12309 2 33218

输出: 3

输入:

10000 3
76892 7 12309
12309 5 -1
10000 1 76892

输出: 7

java代码: 博客里的 我打了备注

  1. import java.util.*;
  2.  
  3. public class Main {
  4.     
  5.     public static class Node{
  6.         String data;
  7.         String next;
  8.         public Node(String data, String next) {
  9.             this.data = data;
  10.             this.next = next;
  11.         }
  12.     }
  13.  
  14.     public static void main(String[] args) {
  15.         //保存 地址 - 节点
  16.         Map<String, Node> map = new HashMap<>();
  17.         Scanner sc = new Scanner(System.in);
  18.         
  19.         //初始化元信息
  20.         String[] mate = sc.nextLine().split(" "); //mate[0] 是 地址 mate[1] 是个数
  21.         
  22.         for(int i = 0; i < Integer.parseInt(mate[1]); i ++ ) {
  23.             String[] info = sc.nextLine().split(" ");//每一行的地址 value next
  24.             map.put(info[0], new Node(info[1], info[2]));
  25.         }
  26.         
  27.         //通过list保存有效数据和记录数据链长度
  28.         List<String> res = new LinkedList<>();//保存结果 list是有序的
  29.         String address = mate[0];//起始地址是第一个
  30.         
  31.         while(true) {
  32.             if(map.containsKey(address) == false)  break;
  33.             //不包含起始地址, 链表为空; 或者找不到下一个地址, 链表结束
  34.             
  35.             Node node = map.get(address);//get(Key) 得到的v就是 Node
  36.             res.add(node.data);//链表保存数据
  37.             address = node.next;//address记录下一个node
  38.         }
  39.         
  40.         //返回中间位置的值
  41.         int idx = res.size() / 2;
  42.         System.out.println(res.get(idx));
  43.         
  44.         
  45.     }
  46.     
  47. }

20 最小的调整次数

输入:

3
head add 1
remove 
tail add 2
head add 3
remove 
remove

输出: 1

java代码

  1. import java.util.*;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.  
  7.         Scanner sc = new Scanner(System.in);
  8.         int n = Integer.parseInt(sc.nextLine());//读取数据范围
  9.         
  10.         int cnt = 0;//变幻的次数
  11.         int left = 0;//剩下待移除的数字
  12.         boolean flag = false;//是否需要逆转
  13.         
  14.         //2n 行
  15.         for(int i = 0; i < 2 * n; i ++ ) {
  16.             
  17.             //读取一行 head add 1 或者 remove
  18.             String[] str = sc.nextLine().split(" ");
  19.         
  20.             if(str.length == 3 ) {//add操作
  21.             
  22.                 if(left != 0) {//有数字的情况下
  23.                 
  24.                     //如果是head, 就要调整一次顺序
  25.                     if(str[0].equals("head") && !flag ) { //不需要调整 
  26.                         flag = true;//标记需要调整
  27.                     }
  28.                     //如果是tail, 不用管, 直接添加
  29.                 }
  30.                 
  31.                 //如果left==0, 不管头和尾都直接添加
  32.                 left ++ ;//数字添加
  33.             }
  34.             
  35.             if(str.length == 1) {//移除操作
  36.                 left -- ;//数字减少
  37.                 cnt += flag ? 1 : 0;//是不是需要调整, 需要的话结果+1
  38.                 flag = false;//调整完结束
  39.             }
  40.             
  41.          }
  42.          
  43.          System.out.println(cnt);
  44.     }
  45. }

这个题目的意思是 一次调整可以调整所有的数, 所以一直等待一个head插入就可以计数了

21 字符串解密

java代码 自己打了备注

  1. import java.util.*;
  2.  
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         
  6.         Scanner sc = new Scanner(System.in);
  7.         
  8.         String s1 = sc.nextLine();
  9.         String s2 = sc.nextLine();
  10.         
  11.         //处理字符串2
  12.         HashSet<String> set = new HashSet<>();
  13.         for(char c : s2.toCharArray()) {//把字符串2变成字符数组 遍历每个字符
  14.             set.add(c + "");//把每个字符都存到set中 set是自动去重的 
  15.         }
  16.         
  17.         //处理字符串1
  18.         String sub = "123456789abcdef";
  19.         //去掉0-9 a-f
  20.         int index = 0;//起始点
  21.         ArrayList<String> list = new ArrayList<>();//保存删除0-9 a-f后的 字符串数组
  22.             //保存筛选后的字符串
  23.         for(int i = 0; i < s1.length(); i ++ ) {
  24.             
  25.             if(sub.contains(s1.charAt(i) + "")) {//遍历到0-9 a-f时, 保存当前字符串
  26.                 list.add(s1.substring(index, i));//substring(1,1)是空, 所以不保存
  27.                 index = i + 1;
  28.             } else {
  29.                 if(i == s1.length() - 1) { //遍历到结尾的时候
  30.                     list.add(s1.substring(index));
  31.                 }
  32.             }
  33.             
  34.         }
  35.         
  36.         String res = "";
  37.         for(int i = 0; i < list.size(); i ++) {//枚举i 获得每个子字符串
  38.             
  39.             String cs = list.get(i);//list里面每个子字符串
  40.             
  41.             
  42.             if(cs.length > 0) {
  43.                 
  44.                 //hashset会自动去重, 获得的长度就是去重后的
  45.                 HashSet<String> cset = new HashSet<>();
  46.                 for(int j = 0; j < cs.length(); j++ ) {
  47.                     cset.add(cs.charAt(j) + "" );
  48.                 }
  49.                 int len = cset.size();//去重后 每个子串的长度
  50.                 
  51.                 //如果这个子串满足题目要求的条件:  < 字符串2的长度
  52.                 if (len <= set.size()) {
  53.                     //就把结果字符串去重 
  54.                     HashSet<String> sset = new HashSet<>();
  55.                     for (int j = 0; j < res.length(); j++) {
  56.                         sset.add(res.charAt(j) + "");
  57.                     }
  58.                     int slen = sset.size();
  59.                     
  60.                     //如果子串长度 > 结果串长度, 更新结果
  61.                     if (len > slen) {
  62.                         res = cs;
  63.                     } else if (len == slen && cs.compareTo(res) > 0) {//字典序
  64.                         res = cs;//如果子串长度相同, 字典序更大 也更新结果
  65.                     }
  66.  
  67.                 }
  68.                 
  69.                 
  70.  
  71.             }
  72.  
  73.         }
  74.         
  75.         
  76.         if (res.length() > 0) {
  77.             System.out.println(res);
  78.         } else {
  79.             System.out.println("Not Found");
  80.         }
  81.          
  82.         
  83.     }
  84.  
  85. }

22 投篮大赛

java代码

  1. import java.util.*;
  2.  
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         String s = sc.nextLine();
  7.         
  8.         String[] nums = s.split(" ");
  9.         
  10.         List<Integer> list = new ArrayList<>();
  11.         
  12.         int res = 0;
  13.         for(int i = 0; i < nums.length; i ++ ) {//遍历每个串
  14.             
  15.             if(nums[i].equals("+")) {
  16.                 
  17.                 int j = list.size();
  18.                 if(list.size() < 2) {//需要集合 >= 2 才能+
  19.                     System.out.println("-1");
  20.                     return;
  21.                 }
  22.                 
  23.                 int grade = list.get(j - 1) + list.get(j - 2);//倒数第一个和倒数第二个
  24.                 list.add(grade);
  25.                 
  26.             } else if (nums[i].equals("D")) {
  27.                 
  28.                 int j = list.size();
  29.                 if(list.size() < 1) {//需要集合 >= 1 需要前面有一个数字
  30.                     System.out.println("-1");
  31.                     return;
  32.                 }
  33.                 
  34.                 int grade = list.get(j - 1) * 2;
  35.                 list.add(grade);
  36.                 
  37.             } else if(nums[i].equals("C") ) {
  38.                 
  39.                 if(list.size() < 1 ) {//需要集合 >= 1 前面有1个数据
  40.                     System.out.println("-1");
  41.                     return;
  42.                 }
  43.                 list.remove(list.size() - 1);//去掉最后一个数字
  44.                 
  45.             } else {//直接添加
  46.                 list.add(new Integer(nums[i]));
  47.             }
  48.             
  49.         }
  50.         for(int i = 0; i < list.size(); i ++ ) {
  51.             res += list.get(i);
  52.         }
  53.         
  54.         System.out.println(res);
  55.     }
  56. }

23 任务总执行时长

java 

咱们就是说, 我只会写这种

  1. // 本题为考试单行多行输入输出规范示例，无需提交，不计分。
  2. import java.util.*;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         
  6.         Scanner in = new Scanner(System.in);
  7.         String[] input = in.nextLine().split(",");
  8.         
  9.         int taskA = Integer.valueOf(input[0]);        
  10.         int taskB = Integer.valueOf(input[1]);
  11.         int nums = Integer.valueOf(input[2]);
  12.         
  13.         HashSet<Integer> set = new HashSet<>();
  14.         
  15.         if(nums != 0){
  16.             int countA = nums;
  17.             while(countA >= 0){
  18.                 int countB = nums - countA;
  19.                 set.add(countA * taskA + countB * taskB);
  20.                 countA -- ;
  21.             }
  22.         }
  23.         
  24.         List<Integer> ans = new ArrayList<>(set);
  25.         
  26.         Collections.sort(ans);
  27.         
  28.         System.out.println(ans);
  29.     }
  30.     
  31. }

24 找数字

java

这个可以看下原链接 满分解法 好像写的更好, 没来得及看

  1. import java.util.*;
  2.  
  3. //找数字
  4. public class Main {
  5.  
  6.     public static void main(String[] args) {
  7.         Scanner sc = new Scanner(System.in);
  8.  
  9.         int row = sc.nextInt();
  10.         int col = sc.nextInt();
  11.  
  12.         int[][] nums = new int[row][col];
  13.         for(int i = 0; i < row; i ++ ) {
  14.             for(int j = 0; j < col; j ++ ) {
  15.                 nums[i][j] = sc.nextInt();
  16.             }
  17.         }
  18.  
  19.         HashMap<Integer, List<int[]>> map = new HashMap<>();//存<数字, {{坐标}, {坐标} ..}>
  20.         for(int i = 0; i < row; i ++ ) {
  21.             for(int j = 0; j < col; j ++ ) {
  22.                 List<int[]> list;
  23.  
  24.                 if(map.containsKey(nums[i][j])) {
  25.                     list = map.get(nums[i][j]);
  26.                 } else {
  27.                     list = new ArrayList<>();
  28.                 }
  29.                 list.add(new int[]{i, j});
  30.                 map.put(nums[i][j], list);
  31.             }
  32.         }
  33.  
  34.  
  35.         ArrayList<List<Integer>> resList = new ArrayList<>();
  36.         for(int i = 0; i < row; i ++ ) {
  37.             ArrayList<Integer> row_list = new ArrayList<>();//一行的结果
  38.             for(int j = 0; j < col; j ++ ) {//该行每个数字
  39.  
  40.                 int key = nums[i][j];
  41.  
  42.                 List<int[]> sites = map.get(key);//每个数字的坐标集合
  43.                 if(sites.size() == 1) {
  44.                     row_list.add(-1);
  45.                     continue;//遍历下一个数字
  46.                 }
  47.  
  48.                 int res = Integer.MAX_VALUE;
  49.                 //当坐标集合>1时 遍历每个集合
  50.                 for(int k = 0; k < sites.size(); k ++ ) {
  51.                     int[] ints = sites.get(k);
  52.                     int x = ints[0];
  53.                     int y = ints[1];
  54.                     //距离
  55.                     int distance = Math.abs(x - i) + Math.abs(y - j);
  56.                     if(distance == 0) continue;//否则把自己比较进去了 0 也会影响结果
  57.                     res = Math.min(distance, res);//每个结果都更新
  58.                 }
  59.                 row_list.add(res);
  60.             }
  61.             resList.add(row_list);
  62.         }
  63.  
  64.  
  65.         System.out.println(resList);
  66.     }
  67.  
  68. }

26 箱子之形摆放

java

map存<位置, 结果字符串> 

  1. import java.util.*;
  2.  
  3. //26 箱子的摆放
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.         String[] strings = sc.nextLine().split(" ");
  8.         String str = strings[0];
  9.         int n = Integer.parseInt(strings[1]);
  10.  
  11.         char[] chars = str.toCharArray();
  12.  
  13.         //用map存每一行
  14.         //k-v是 <Integer. String>
  15.         // key是行数, values每一行的内容 把该位置的字符拼到values
  16.         HashMap<Integer, String> res = new HashMap<>();//<0,A> <1,B> <2,C>
  17.         for(int i = 0 ; i < str.length(); i += n ) {
  18.             if(i / n % 2 == 0) {//偶数列 正序
  19.                 for(int j = 0; j < n; j ++ ) {
  20.                     if(i + j < str.length()) {
  21.                         if(res.containsKey(j)) {
  22.                             String value = res.get(j);//必须要判断 否则会把null加进去
  23.                             value += str.charAt(j + i);
  24.                             res.put(j, value);
  25.                         } else {
  26.                             res.put(j, String.valueOf(str.charAt(j + i)));
  27.                         }
  28.                     }
  29.                 }
  30.             } else {//奇数 倒序
  31.                 for(int j = 0; j < n; j ++ ) {
  32.                     if(res.containsKey(j)) {
  33.                         String value = res.get(n - 1 - j);
  34.                         value += str.charAt(j + i);
  35.                         res.put(n - 1 - j, value);
  36.                     } else {
  37.                         res.put(n - 1 - j, String.valueOf(str.charAt(j + i)));
  38.                     }
  39.                 }
  40.             }
  41.         }
  42.  
  43.         for(String sb: res.values()) {
  44.             System.out.println(sb);
  45.         }
  46.  
  47. //        for(Map.Entry<Integer, String> map : res.entrySet()) {
  48. //            System.out.println(map.getValue());
  49. //        }
  50.  
  51.     }
  52. }

27 异常的打卡记录

java

  1. import java.util.*;
  2.  
  3. //找数字
  4. public class Main {
  5.  
  6.     public static void main(String[] args) {
  7.         Scanner sc = new Scanner(System.in);
  8.  
  9.         int n = sc.nextInt();//打卡记录数
  10.         sc.nextLine();
  11.         HashMap<Integer, List<int[]>> map = new HashMap<>();
  12.  
  13.         //遍历每个打卡记录
  14.         ArrayList<String> alls = new ArrayList<>();
  15.         for(int i = 0; i < n; i ++ ) {
  16.             String str = sc.nextLine();
  17.             //System.out.println(str);
  18.             String[] strings = str.split(",");
  19.             alls.add(str);
  20.             int id = Integer.parseInt(strings[0]);
  21.             int time = Integer.parseInt(strings[1]);
  22.             int distance = Integer.parseInt(strings[2]);
  23.             if(map.containsKey(id)) {
  24.                 List<int[]> list = map.get(id);
  25.                 list.add(new int[]{time, distance});
  26.                 map.put(id, list);
  27.             } else {
  28.                 ArrayList<int[]> list = new ArrayList<>();
  29.                 list.add(new int[]{time, distance});
  30.                 map.put(id, list);
  31.             }
  32.         }
  33.  
  34.         ArrayList<Integer> res = new ArrayList<>();
  35.         //遍历每个map 找重复打卡的人是不是有异常
  36.         for(Map.Entry<Integer, List<int[]>> entry : map.entrySet()) {
  37.             Integer id = entry.getKey();
  38.             List<int[]> list = entry.getValue();//{时间, 地点} {} {} ..
  39. //            if(list.size() == 1) {
  40. //                //打卡记录一次, 不存在两次打卡距离的问题
  41. //                //判断内部是否需要检查
  42. //            }
  43.             if(list.size() != 1) {//比较 任意两个数组
  44.                 for(int i = 0; i < list.size() - 1; i ++ ) {
  45.                     int[] ints = list.get(i);
  46.                     int time1 = ints[0];
  47.                     int distance1 = ints[1];
  48.                     for(int j = i + 1; i < list.size(); i ++ ) {
  49.                         int[] ints2 = list.get(i);
  50.                         int time2 = ints2[0];
  51.                         int distance2 = ints2[1];
  52.                         if(Math.abs(time1 - time2) < 60
  53.                                 && Math.abs(distance1 - distance2) > 5) {
  54.                             res.add(id);
  55.                         }
  56.                     }
  57.                 }
  58.             }
  59.         }
  60.  
  61.         //遍历每个打卡记录 集合alls里面的
  62.         boolean flag = true;
  63.         StringBuilder ans = new StringBuilder();
  64.         for(int i = 0; i < n; i ++ ) {
  65.             String str = alls.get(i);
  66.             String[] strings = str.split(",");
  67.             int id = Integer.parseInt(strings[0]);
  68.             String log = strings[3];
  69.             String register = strings[4];
  70.             if(res.contains(id)) {
  71.                 //System.out.println(str);
  72.                 ans.append(str);
  73.                 ans.append(" ");
  74.                 flag = false;
  75.             } else if(!log.equals(register)) {
  76.                 //System.out.println(str);
  77.                 ans.append(str);
  78.                 ans.append(" ");
  79.                 flag = false;
  80.             }
  81.         }
  82.         if(flag) System.out.println("null");
  83.         else System.out.println(ans.toString().trim().replace(" ", ";"));
  84.  
  85.     }
  86.  
  87. }

28 最左侧冗余覆盖子串

  1. import java.util.*;
  2.  
  3. //28 最左侧冗余覆盖子串
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String s1 = sc.nextLine();
  9.         String s2 = sc.nextLine();
  10.  
  11.         int k = sc.nextInt();
  12.  
  13.         int n1 = s1.length();
  14.         int n2 = s2.length();
  15.         int len = n1 + k;
  16.  
  17.         for(int i = 0; i < n2 - len + 1; i ++ ) {//枚举子串开始的下标
  18.             String tmp = "";
  19.             for(int j = 0; j < len; j ++ ) {//子串长度
  20.                 tmp += s2.charAt(j + i);
  21.             }
  22.             if(tmp.contains(s1)) {
  23.                 System.out.println(i);
  24.                 return;
  25.             }
  26.         }
  27.         System.out.println("-1");
  28.  
  29.     }
  30. }

或者substring

  1.  
  2.         for(int i = 0; i < n2 - len + 1; i ++ ) {//枚举子串开始的下标
  3.             String tmp = s2.substring(i, i + len);
  4.             if(tmp.contains(s1)) {
  5.                 System.out.println(i);
  6.                 return;
  7.             }
  8.         }

29 最多提取子串数目

  1. import java.util.*;
  2.  
  3. //29 最多提取子串数目
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String stra = sc.nextLine();//父字符串
  9.         String strb = sc.nextLine();
  10.  
  11.         //char[] charsa = stra.toCharArray();//父字符串的字符数组
  12.  
  13.         int len = stra.length();
  14.         int[] a = new int[len];//数组 保存是否已经被取过 0/1 没取过 是 0
  15.  
  16.         int i = 0, j = 0;
  17.         int cnt = 0;
  18.         while (i < stra.length()) {
  19.             if (stra.charAt(i) == strb.charAt(j) && a[i] == 0) {//匹配上了
  20.                 a[i] = 1;
  21.                 //匹配上了 需要判断: 如果匹配完子串, 父串从0开始, 否则父串i++往后移动
  22.                 j ++ ;//子串往后移动
  23.             }
  24.             if (j == strb.length()) {//子串遍历到尾巴了 说明都匹配上了
  25.                 cnt ++ ;
  26.                 j = 0;
  27.                 i = 0;
  28.             } else {
  29.                 i ++ ;//父串继续往后遍历
  30.             }
  31.  
  32.         }
  33.         System.out.println(cnt);
  34.     }
  35. }

30 找出通过车辆最多颜色

java: 

  1. import java.util.*;
  2.  
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         String[] strings = sc.nextLine().split(" ");
  7.         int n = sc.nextInt();//n秒时间
  8.  
  9.         int res = 0;
  10.         for(int i = 0; i < strings.length - n + 1; i ++ ) {
  11.             //类似滑动窗口, 遍历每个窗口
  12.             int[] ints = new int[3];//3中颜色
  13.             for(int j = i; j < n; j ++ ) {
  14.                 int num = Integer.parseInt(strings[j]);
  15.                 ints[num] ++ ;
  16.             }//遍历完得到这个窗口的每个颜色个数
  17.  
  18.             int max = Arrays.stream(ints).max().getAsInt();
  19.             //Arrays.stream(intArr); 转成int流, 可以求sum max min average()
  20.             res = Math.max(res, max);
  21.         }
  22.  
  23.         System.out.println(res);
  24.  
  25.     }
  26. }

31 优秀学员统计

java

  1. import java.util.*;
  2.  
  3. //26 箱子的摆放
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int n = sc.nextInt();//员工数量
  9.         //sc.nextLine();
  10.  
  11.         int[] nums = new int[30];//30天 每天打卡人数
  12.         for (int i = 0; i < 30; i++) {
  13.             nums[i] = sc.nextInt();//第i的打卡人数
  14.         }
  15.  
  16.         //int[] cnts = new int[n];//下标是id, 大小是打卡次数
  17.         //换成用map存 <Integer, int[]> <id, {最早打卡时间, 打卡天数}>
  18.         //用map存, <integer, int[2]> 员工工号 - (第一次打卡时间, 打卡数)
  19.         HashMap<Integer, int[]> res = new HashMap<>();
  20.    
  21.  
  22.         for (int i = 0; i < 30; i++) {//循环30天
  23.             for(int j = 0; j < nums[i]; j ++ ) {
  24.                 int id = sc.nextInt();
  25.                 if(res.containsKey(id)) {//包含这个员工
  26.                     int[] tmp = res.get(id);
  27.                     tmp[1] ++;
  28.                     res.put(id, tmp);
  29.                 } else {
  30.                     int[] tmp = new int[2];
  31.                     tmp[0] = i;
  32.                     tmp[1] = 1;
  33.                     res.put(id, tmp);
  34.                 }
  35.             }
  36.         }
  37.  
  38.         List<Map.Entry<Integer, int[]>> resList = new ArrayList<>(res.entrySet());
  39.         resList.sort(new Comparator<Map.Entry<Integer, int[]>>() {
  40.             @Override
  41.             public int compare(Map.Entry<Integer, int[]> o1, Map.Entry<Integer, int[]> o2) {
  42.                 if(o1.getValue()[1] == o2.getValue()[1]) {
  43.                     return o1.getValue()[0] - o2.getValue()[0];//按照打卡时间 从小到大
  44.                 } else {
  45.                     return o2.getValue()[1] - o1.getValue()[1];//按照打卡天数 从大到小
  46.                 }
  47.             }
  48.         });
  49.  
  50.         StringBuilder ans = new StringBuilder();
  51.         for(int i = 0; i < (Math.min(resList.size(), 5)); i ++ ) {//前五 员工 的 id
  52.             ans.append(resList.get(i).getKey()).append(" ");
  53.         }
  54.         System.out.println(ans.substring(0, ans.length() - 1));
  55.  
  56.     }
  57. }

考的时候写的 救命 紧张了 写的比原来复杂, 不过也是满分 

  1. import java.util.*;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         /*
  9.             11
  10.             4 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2
  11.             0 1 7 10
  12.             0 1 6 10
  13.             10
  14.             10
  15.             10
  16.             10
  17.             10
  18.             10
  19.             10
  20.             10
  21.             10
  22.             10
  23.             10
  24.             10
  25.             10
  26.             10
  27.             10
  28.             10
  29.             10
  30.             10
  31.             10
  32.             10
  33.             10
  34.             10
  35.             10
  36.             10
  37.             10
  38.             10
  39.             6 10
  40.             7 10
  41.         */
  42.         //员工情况 int[]
  43.  
  44.         int n = sc.nextInt();//新员工数量
  45.  
  46.         int[] empls = new int[30];//每天打卡的员工数量
  47.         for(int i = 0; i < 30; i ++ ) {
  48.             empls[i] = sc.nextInt();
  49.         }
  50.  
  51.         int[] cnts = new int[n];//保存员工打卡的数量
  52.         int[] first = new int[n];
  53.         for(int i = 0; i < 30; i ++ ) {//天数
  54.             for(int j = 0; j < empls[i]; j ++ ){
  55.                 int id = sc.nextInt();//员工编号
  56.                 if(cnts[id] == 0) first[id] = i;
  57.                 cnts[id] ++ ;
  58.             }
  59.         }
  60.  
  61.         //map <员工id, 员工打卡情况int[]{最早打卡时间, 打卡总数}>
  62.  
  63.         HashMap<Integer, int[]> map = new HashMap<>();
  64.  
  65.         for(int i = 0; i < n; i ++ ) {
  66.             int days = cnts[i];//每个员工打卡次数
  67.             int date = first[i];//最早打卡日期
  68.             //i是员工id
  69.                 int[] ints = new int[2];
  70.                 ints[0] = date;
  71.                 ints[1] = days;
  72.                 map.put(i, ints);
  73.  
  74.         }
  75.  
  76.         ArrayList<Map.Entry<Integer, int[]>> list = new ArrayList<>(map.entrySet());
  77.         list.sort(new Comparator<Map.Entry<Integer, int[]>>() {
  78.             @Override
  79.             public int compare(Map.Entry<Integer, int[]> o1, Map.Entry<Integer, int[]> o2) {
  80.                 if(o1.getValue()[1] == o2.getValue()[1]) {//打卡次数相同时候
  81.                     if(o1.getValue()[0] == o2.getValue()[0]) {//打卡时间相同
  82.                         return o1.getKey() - o2.getKey();//打卡id较小的员工
  83.                     }
  84.                     return o1.getValue()[0] - o2.getValue()[0];//较早打卡的员工排在前
  85.                 }
  86.                 return o2.getValue()[1] - o1.getValue()[1];//打卡次数
  87.             }
  88.         });
  89.  
  90.         String res = "";
  91.         int len = Math.min(5, list.size());
  92.  
  93.         for(int i = 0; i < len; i ++ ) {
  94.             res += list.get(i).getKey();
  95.             if(i != len - 1) res += " ";
  96.         }
  97.  
  98.         System.out.println(res);
  99.  
  100.     }
  101.  
  102. }

32 租车骑绿道

java 我写的

  1. import java.util.*;
  2.  
  3. //32 租车骑绿道
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int m = sc.nextInt();//限重m
  9.         int n = sc.nextInt();//人数n
  10.  
  11.         int[] a = new int[n];
  12.         for (int i = 0; i < n; i++) {
  13.             a[i] = sc.nextInt();//每个人的体重
  14.         }
  15.  
  16.         Arrays.sort(a);//从小到大排序
  17.         int cnt = 0;
  18.         int[] flag = new int[n]; //0
  19.         //双指针遍历 一个从小到大, 一个从大到小
  20.         int i = 0, j = n - 1;
  21.         while (i < j) {
  22.             //如果和超过限制了
  23.             if (a[i] + a[j] > m) {
  24.                 cnt ++ ;//给最后一个++一辆车
  25.                 flag[j] = 1;
  26.                 j--;
  27.             }
  28.  
  29.             if (a[i] + a[j] <= m) {
  30.                 cnt++;//给i和 j 分配 一辆车
  31.                 flag[i] = 1;
  32.                 flag[j] = 1;
  33.                 i++;
  34.                 j--;
  35.             }
  36.         }
  37.         if(flag[i] == 0) cnt ++;//以防最中间剩下一个 没加上//比如 1 1 2 2 3 4 4 4 5 5, 剩下2
  38.  
  39.         System.out.println(cnt);
  40.     }
  41.  
  42. }

33 相同数字的积木游戏

我写的: 

  1. import java.util.*;
  2. import java.util.stream.Stream;
  3. //33 相同数字的积木游戏
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int n = sc.nextInt();
  9.         int[] a = new int[n];
  10.         for(int i = 0; i < n; i ++ ) {
  11.             int num = sc.nextInt();
  12.             a[i] = num;//存进数组
  13.         }
  14.         //双指针 一个从前往后遍历 一个从后往前遍历
  15.         //结果保存到res
  16.         int res = -1;
  17.         for(int i = 0; i < n; i ++ ) {
  18.             int tmp = a[i];
  19.             for(int j = n - 1; j > i; j -- ) {
  20.                 if(tmp == a[j]) {
  21.                     res = Math.max(res, j - i);
  22.                     break;
  23.                 }
  24.             }
  25.         }
  26.         System.out.println(res);
  27.  
  28.     }
  29. }

考试时候写的 , 救命 一紧张又写复杂了

  1. import java.util.*;
  2.  
  3. public class Main {
  4.  
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.         int n = sc.nextInt();
  8.  
  9.         HashMap<Integer, List<Integer>> map = new HashMap<>();//存<数字, 位置int>
  10.  
  11.         for(int i = 0 ; i < n; i ++ ) {
  12.             int tmp = sc.nextInt();
  13.             if(map.containsKey(tmp)) {
  14.                 List<Integer> list = map.get(tmp);
  15.                 list.add(i);
  16.                 map.put(tmp, list);
  17.             } else {
  18.                 ArrayList<Integer> list = new ArrayList<>();
  19.                 list.add(i);
  20.                 map.put(tmp, list);
  21.             }
  22.         }
  23.  
  24.         boolean flag = true;
  25.         int ans = -1;
  26.         for(Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
  27.             List<Integer> list = entry.getValue();
  28.             if(list.size() > 1) {
  29.                 flag = false;
  30.                 int res = 0;
  31.                 int len = list.size();
  32.                 for(int i = 0; i < len - 1; i ++ ) {
  33.                     for(int j = i + 1; j < len; j ++ ) {
  34.                         //遍历 得到一个数字的最大距离
  35.                         res = Math.max(res, list.get(j) - list.get(i));
  36.                     }
  37.                 }
  38.                 //每个数字的最大距离都更新
  39.                 ans = Math.max(res, ans);
  40.             }
  41.         }
  42.  
  43.         System.out.println(ans);
  44.  
  45.     }
  46.  
  47. }

java满分答案:

  1. import java.util.Scanner;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         Scanner in = new Scanner(System.in);
  5.         int num = in.nextInt();
  6.         int[] arr = new int[num];
  7.         for(int i=0;i<num;i++){
  8.             arr[i] = in.nextInt();
  9.         }
  10.         int max=-1;
  11.         for(int i=0;i<num;i++){
  12.             for(int j=i+1;j<num;j++){
  13.                 if(arr[i]==arr[j]){
  14.                     max = Math.max(max,j-i);
  15.                 }
  16.             }
  17.         }
  18.         
  19.         System.out.println(max);
  20.     }
  21. }

34工作安排

01背包问题

f[i][j]表示只考虑前i个物品, 总体不超过j的情况下, 总价值最大是多少

状态转移 f[i][j]

        1.不选第i个物品: f[i][j] = f[i - 1][j]

        2.选第i个物品: f[i][j] = f[i - 1][j - v[i]] + w[i]

        装不下的时候 f[i][j] = f[i - 1][j] (这个情况是一定存在的

        能装下的时候, 可以选或者不选, f[i][j] = max(第一种情况, 第二种情况)   (这个情况不一定存在 要判断)

f[0][0] = 0 默认0 初始化不需要写了

c++ 代码

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. //01背包 二维数组做法
  6. const int N = 1010;
  7.  
  8. int n, m; // 物品数量, 背包容量
  9. int v[N], w[N]; // 体积 价值
  10. int f[N][N]; // f[i][j], 前 i 个物品中体积不超过 j 的最大价值
  11.  
  12. int main()
  13. {
  14.     cin >> m >> n;// 输入物品数量n, 背包容量m
  15.     for (int i = 1; i <= n; i++) cin >> v[i] >> w[i] ;//输入背包内所有东西的体积和价值
  16.  
  17.     for (int i = 1; i <= n; i++) // 物品数量<n
  18.         for (int j = 0; j <= m; j++) // 背包
  19.         {
  20.             // 当前背包容量装不下第 i 个物品, 则价值等于前 i-1 个物品
  21.             f[i][j] = f[i - 1][j];
  22.             // 当前背包容量能装下第 i 个物品, 选择是否装第 i 个物品, 取较大的那个结果
  23.             if (j >= v[i]) f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
  24.         }
  25.  
  26.     cout << f[n][m] << endl;
  27.  
  28.     return 0;
  29. }

c++ 一维数组做法:

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. //01背包 一维数组做法
  6. const int N = 1010;
  7.  
  8. int n, m; // 物品数量, 背包容量
  9. int v[N], w[N]; // 体积 价值
  10. int f[N]; // 最大价值
  11.  
  12. int main()
  13. {
  14.     cin >> m >> n;// 输入物品数量, 背包容量
  15.     for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];//输入背包内所有东西的体积和价值
  16.  
  17.     for (int i = 1; i <= n; i++) // 物品数量<n
  18.         for (int j = m; j >= v[i]; j--) // 背包
  19.             f[j] = max(f[j], f[j - v[i]] + w[i]);//max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
  20.  
  21.     cout << f[m] << endl;
  22.  
  23.     return 0;
  24. }

35 预定酒店

java

  1. import java.util.*;
  2. import java.util.stream.Stream;
  3.  
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String[] strs = sc.nextLine().split(" ");
  9.  
  10.         int n = Integer.parseInt(strs[0]);
  11.         int k = Integer.parseInt(strs[1]);
  12.         int x = Integer.parseInt(strs[2]);
  13.         Integer[] integers =
  14.                 Arrays.stream(sc.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
  15.  
  16.  
  17.         ArrayList<int[]> list = new ArrayList<>();
  18.         for(int i = 0; i < n; i ++ ) {
  19.             Integer price = integers[i];
  20.             int[] ints = new int[2];
  21.             ints[0] = price;
  22.             ints[1] = Math.abs(x - price);//距离价格的绝对值
  23.             list.add(ints);
  24.         }
  25.  
  26.         //排序 按照绝对值 和 价格大小
  27.         list.sort(((o1, o2) -> {
  28.             if (o1[1] == o2[1]) {//比较二者
  29.                 return o1[0] - o2[0];//如果绝对值相同 比比较数字大小 取较小的
  30.             } else {
  31.                 return o1[1] - o2[1];//如果绝对值不同, 先按绝对值比较, 取绝对值小的
  32.             }
  33.         }));
  34.  
  35.         //把前k个结果保存到结果数组
  36.         ArrayList<Integer> res = new ArrayList<>();
  37.  
  38.         //输出前k个
  39.         for(int i = 0; i < k; i ++ ) {
  40.             int i1 = list.get(i)[0];
  41.             res.add(i1);
  42.         }
  43.  
  44.         //按照值排序
  45.         Collections.sort(res);
  46.  
  47.         for(int i = 0; i < k; i ++ ) {
  48.             System.out.print(res.get(i));
  49.             if(i != k - 1) System.out.print(" ");
  50.         }
  51.  
  52.         // 参考答案中去除最后一个空格的方法:
  53. //        StringBuilder sb = new StringBuilder();
  54. //        for (int i = 0; i < res.size(); i++) {
  55. //            sb.append(res.get(i)).append(" ");
  56. //        }
  57. //
  58. //        System.out.println(sb.deleteCharAt(sb.length()-1));
  59.  
  60.     }
  61. }

36 学校的位置

给学生家排序, 如果个数是奇数, 就在中间位置的学生家

如果是偶数, 就在中间两个位置的学生家之间, 题意要求输出较小的位置, 就是中间两个位置中靠左的那一个

这个用c++写更简单, java的话位移要加括号, 否则会报错

  1. import java.util.*;
  2.  
  3. //学校的位置
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int n = sc.nextInt();
  9.  
  10.         int[] sites = new int[n];
  11.         for(int i = 0; i < n; i ++ ) {
  12.             sites[i] = sc.nextInt();//存储家庭的位置
  13.         }
  14.         //排序
  15.         Arrays.sort(sites);
  16.  
  17.         int res;
  18.         if(n % 2 == 0) {
  19.             res = sites[(n >> 1) - 1];
  20.         } else {
  21.             res = sites[(n - 1) >> 1];
  22.         }
  23.  
  24.         System.out.println(res);
  25.     }
  26. }

37 寻找密码

  1. import java.util.*;
  2.  
  3. //37 寻找密码
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String[] strings = sc.nextLine().split(" ");
  9.  
  10.         HashSet<String> set = new HashSet<>();
  11.         set.addAll(Arrays.asList(strings));
  12.  
  13.         String str = "";//结果字符串
  14.         for (String string : strings) {
  15.  
  16.             if (check(set, string)) {
  17.                 if (string.length() > str.length()) {
  18.                     str = string;
  19.                 }
  20.                 if (string.length() == str.length() && string.compareTo(str) > 0) {
  21.                     str = string;
  22.                 }
  23.             }
  24.  
  25.         }
  26.  
  27.         System.out.println(str);
  28.  
  29.     }
  30.  
  31.     public static boolean check(Set<String> set, String str) {
  32.         String tmp = str;
  33.         boolean flag = true;
  34.         //最大的密码就是 str str缩短 查询set的子集就好了
  35.         for(int i = str.length() - 1; i > 0; i -- ) {
  36.             tmp = str.substring(0, i);
  37.             if(!set.contains(tmp)) flag = false;
  38.         }
  39.  
  40.         return flag;
  41.     }
  42.  
  43. }

38 寻找关键钥匙

  1. import java.util.*;
  2.  
  3. //38 寻找关键钥匙
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String key = sc.nextLine();
  9.         String[] boxes = sc.nextLine().split(" ");
  10.  
  11.         for(int i = 0; i < boxes.length; i ++ ) {
  12.             String str = "";//保存待比较的字符串
  13.             for(int j = 0; j < boxes[i].length(); j ++ ) {
  14.                 char c = boxes[i].charAt(j);
  15.                 c = Character.toLowerCase(c);
  16.                 if(c >= 'a' && c <= 'z') str += c;
  17.             }
  18.  
  19.             //str = str.toLowerCase();//或者这么写 字符串转换
  20.             char[] chars = str.toCharArray();//每个box转成 char数组
  21.  
  22.             Arrays.sort(chars);
  23.  
  24.             if(String.valueOf(chars).equals(key)) {
  25.                 System.out.println(i + 1);
  26.                 return;
  27.             }
  28.  
  29.         }
  30.  
  31.         System.out.println("-1");
  32.  
  33.     }
  34. }

39 查找充电设备组合 TODO

java

  1. import java.util.*;
  2.  
  3. //39 查找充电设备组合
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int n = sc.nextInt();
  9.         ArrayList<Integer> list = new ArrayList<>();//存储充电设备的集合
  10.         for(int i = 0; i < n; i ++ ) {
  11.             list.add(sc.nextInt());
  12.         }
  13.         int p_max = sc.nextInt();//最大功率
  14.  
  15.         int max = 0;//结果数组里的最大功率
  16.         HashSet<Integer> res = new HashSet<>();
  17.         res.add(0);//存一个0
  18.         for(Integer num : list){
  19.             HashSet<Integer> tmps = new HashSet<>();//每一次遍历的临时数组
  20.             for(Integer power : res) {//循环一遍每个结果
  21.                 int new_p = power + num;
  22.                 if(new_p <= p_max) {
  23.                     tmps.add(new_p);//做临时数组来存, 否则会改变遍历的情况
  24.                     max = Math.max(new_p, max);
  25.                 }
  26.             }
  27.             res.addAll(tmps);
  28.         }
  29.  
  30.         System.out.println(max);
  31.  
  32.     }
  33. }

40 知识图谱新词挖掘

  1. import java.util.*;
  2.  
  3. //39 查找充电设备组合
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         String content = sc.nextLine();
  9.         String word = sc.nextLine();
  10.         int len_c = content.length();
  11.         int len_w = word.length();
  12.  
  13.         char[] words = word.toCharArray();
  14.         Arrays.sort(words);//排序后
  15.  
  16.         int count = 0;
  17.         for(int i = 0; i < len_c - len_w + 1; i ++ ) {
  18.             String new_word = content.substring(i, len_w + i);
  19.             char[] new_words = new_word.toCharArray();
  20.             Arrays.sort(new_words);
  21.             if(String.valueOf(new_words).equals(String.valueOf(words))) {
  22.                 count ++;
  23.             }
  24.         }
  25.  
  26.         System.out.println(count);
  27.     }
  28. }

41 静态代码扫描服务

java

记得换行的时候要 sc.NextLine(); !!!!!

  1. import java.util.*;
  2.  
  3. //39 查找充电设备组合
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int m = sc.nextInt();//缓存一个报告的金币数m
  9.         sc.nextLine();//换行了!!!!!
  10.  
  11.         String[] nums = sc.nextLine().split(" ");//标识序列
  12.         String[] sizes = sc.nextLine().split(" ");//每个文件的大小
  13.  
  14.         HashMap<Integer, Integer> numsMap = new HashMap<>();//存储 标识 - 个数
  15.         HashMap<Integer, Integer> sizeMap = new HashMap<>();//存储 标识 - 大小
  16.  
  17.         //把两个map存好
  18.         for(int i = 0; i < nums.length; i ++ ) {
  19.             int num = Integer.parseInt(nums[i]);
  20.             int size = Integer.parseInt(sizes[i]);
  21.             if(numsMap.containsKey(num)) {
  22.                 numsMap.put(num, numsMap.get(num) + 1);
  23.             } else {
  24.                 numsMap.put(num, 1);
  25.                 sizeMap.put(num, size);
  26.             }
  27.         }
  28.  
  29.         int res = 0;
  30.         for(Map.Entry<Integer, Integer> map : numsMap.entrySet()) {
  31.             Integer key = map.getKey();//标识
  32.             Integer value = map.getValue();//文件个数
  33.             Integer size = sizeMap.get(key);//文件大小(扫描一次的成本价格)
  34.             int save = 0;
  35.             int noSave = 0;//每个标识文件 的 存和不存的需要金币数
  36.  
  37.             save = m + size;//缓存一个报告的金币数m + 扫描的成本(文件大小)
  38.             noSave = value * size;//不缓存, 每次都扫描, 大小 * 个数
  39.  
  40.             res += Math.min(save, noSave);
  41.         }
  42.         System.out.println(res);
  43.  
  44.     }
  45. }

42 不爱施肥的小布

java: 

这个向上取整没整明白 ceil为啥没取到呢, 换了朴素写法

  1. import java.util.*;
  2.  
  3. //42
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int m = sc.nextInt();//m个果林
  9.         int n = sc.nextInt();//n天
  10.  
  11.         int[] fields = new int[m];
  12.         for(int i = 0; i < m; i ++ ) {
  13.             fields[i] = sc.nextInt();
  14.         }
  15.         Arrays.sort(fields);
  16.  
  17.         int k = 0;
  18.         int cnt = 0;
  19.         int res = 0;
  20.         for(int i = 0; i < m; i ++ ) {
  21.             k = fields[i];
  22.             cnt += i + 1;//前i个都可以1天完成
  23.             for(int j = i + 1; j < m; j ++ ) {
  24.                 int days = fields[j] / k;
  25.                 if(fields[j] % k != 0) {
  26.                     days ++ ;
  27.                 }
  28. //                int days = (int) Math.ceil(fields[j] / k);//向上取整
  29.                 cnt += days;
  30.             }
  31.             if(cnt <= n) {
  32.                 System.out.println(k);
  33.                 return;
  34.             }
  35.             cnt = 0;
  36.         }
  37.  
  38.         System.out.println("-1");
  39.  
  40.     }
  41. }

44 新员工座位安排系统

我写的

  1. import java.util.*;
  2.  
  3. //44 新员工座位安排
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.         String[] strings = sc.nextLine().split(" ");
  8.  
  9.         int n = strings.length;
  10.         int[] a = new int[n];
  11.         boolean flag = false;
  12.         ArrayList<Integer> indexes = new ArrayList<>();
  13.         for(int i = 0; i < n; i ++ ) {
  14.             a[i] = Integer.parseInt(strings[i]);
  15.             if(a[i] == 0) {
  16.                 flag = true;//只要有0 就改为true
  17.                 indexes.add(i);//存入0点的下标
  18.             }
  19.         }
  20.         if(!flag) {
  21.             System.out.println(0);
  22.             return;
  23.         }
  24.  
  25.         int res = 0;
  26.         int tmp = 0;//当前的友好值
  27.         
  28.         //0点所在的下标
  29.         for (Integer index : indexes) {//枚举每个0点
  30.  
  31.             if (index != 0) {
  32.                 int l = index - 1;
  33.                 while (a[l] == 1) {
  34.                     tmp++;
  35.                     if (l == 0) break;
  36.                     l--;
  37.                 }
  38.             }
  39.             if (index != n - 1) {
  40.                 int r = index + 1;
  41.                 while (a[r] == 1) {
  42.                     tmp++;
  43.                     if (r == n - 1) break;
  44.                     r++;
  45.                 }
  46.             }
  47.  
  48.             res = Math.max(res, tmp);
  49.             tmp = 0;
  50.         }
  51.         System.out.println(res);
  52.  
  53.  
  54.     }
  55. }

45 光伏场地建设规划

java

  1. import java.util.Scanner;
  2. //45 光伏场地建设规划
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         String[] strings = sc.nextLine().split(" ");
  7.  
  8.         int row = Integer.parseInt(strings[0]);
  9.         int col = Integer.parseInt(strings[1]);
  10.  
  11.         int n = Integer.parseInt(strings[2]);
  12.         int min = Integer.parseInt(strings[3]);//最低发电量
  13.  
  14.         int[][] a = new int[row][col];
  15.         for(int i = 0; i < row; i ++  ) {
  16.             for(int j = 0; j < col; j ++ ) {
  17.                 a[i][j] = sc.nextInt();
  18.             }
  19.         }
  20.  
  21.         if(col < n || row < n) {
  22.             System.out.println("0");
  23.             return;
  24.         }
  25.  
  26.  
  27.         int[][] area = new int[n][n];
  28.         int sum = 0;
  29.         int res = 0;
  30.         for(int k = 0; k < row - n + 1; k ++ ) {
  31.             for(int p = 0; p < col - n + 1; p ++ ) {//遍历所有起始点的位置
  32.                 for (int i = 0; i < n; i++) {//正方形内的值
  33.                     for (int j = 0; j < n; j++) {
  34.                         area[i][j] = a[i + k][j + p];//相对地址 +k +p
  35.                         sum += area[i][j];
  36.                     }
  37.                 }
  38.                 if(sum >= min) res ++;
  39.                 sum = 0;
  40.             }
  41.         }
  42.  
  43.         System.out.println(res);
  44.     }
  45. }

java

  1. import java.util.Scanner;
  2. //45 光伏场地建设规划
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System.in);
  6.         String[] strings = sc.nextLine().split(" ");
  7.  
  8.         int row = Integer.parseInt(strings[0]);
  9.         int col = Integer.parseInt(strings[1]);
  10.  
  11.         int n = Integer.parseInt(strings[2]);
  12.         int min = Integer.parseInt(strings[3]);//最低发电量
  13.  
  14.         int[][] a = new int[row][col];
  15.         for(int i = 0; i < row; i ++  ) {
  16.             for(int j = 0; j < col; j ++ ) {
  17.                 a[i][j] = sc.nextInt();
  18.             }
  19.         }
  20.  
  21.         if(col < n || row < n) {
  22.             System.out.println("0");
  23.             return;
  24.         }
  25.  
  26.         int count = (col - n + 1) * (row - n + 1);//总数是这些
  27.  
  28.         int[][] area = new int[n][n];
  29.         int sum = 0;
  30.         for(int k = 0; k < row - n + 1; k ++ ) {
  31.             for(int p = 0; p < col - n + 1; p ++ ) {
  32.                 for (int i = 0; i < n; i++) {
  33.                     for (int j = 0; j < n; j++) {
  34.                         area[i][j] = a[i + k][j + p];
  35.                         sum += area[i][j];
  36.                     }
  37.                 }
  38.                 if(sum < min) count --;//不满足的减掉
  39.                 sum = 0;
  40.             }
  41.         }
  42.  
  43.         System.out.println(count);
  44.     }
  45. }

46 微服务的集成测试 dfs

java

  1. import java.util.*;
  2.  
  3. //微服务的集成测试
  4. public class Main {
  5.  
  6.     public static void main(String[] args) {
  7.         Scanner sc = new Scanner(System.in);
  8.  
  9.         int n = sc.nextInt();
  10.  
  11.         int[][] useTime = new int[n][n];
  12.         for(int i = 0; i < n; i ++ ) {
  13.             for(int j = 0; j < n; j ++ ) {
  14.                 useTime[i][j] = sc.nextInt();
  15.             }
  16.         }
  17.         int k = sc.nextInt();//待计算 的 服务 k
  18.  
  19.         int cnt = 0;
  20.         cnt = dfs(useTime, k - 1);
  21.         System.out.println(cnt);
  22.  
  23.     }
  24.  
  25.     public static int dfs(int[][] useTime, int k) {
  26.         int max = 0;
  27.         // 计算启动服务k的时间
  28.         //遍历k的一行数据, 得到它依赖的服务器, 获得启动时间
  29.         for(int j = 0; j < useTime.length; j ++ ) {
  30.             int tmp = useTime[k][j];
  31.             if(tmp != 0 && j != k ) {
  32.                 max = Math.max(max, dfs(useTime, j));
  33.             }
  34.         }
  35.         return max + useTime[k][k];//依赖的加载时间 max + 自身的加载时间
  36.     }
  37. }

47 字符串重新排序

java

  1. import java.util.*;
  2.  
  3. //微服务的集成测试
  4. public class Main {
  5.  
  6.     public static void main(String[] args) {
  7.         Scanner sc = new Scanner(System.in);
  8.  
  9.         String[] strings = sc.nextLine().split(" ");
  10.  
  11.         HashMap<String, Integer> map = new HashMap<>();
  12.         for(int i = 0; i < strings.length; i ++ ) {
  13.  
  14.             String key = arrange(strings[i]);//单词字典序
  15.             map.put(key, map.getOrDefault(key, 0) + 1);//map存储 单词和出现次数
  16.  
  17.         }
  18.  
  19.         ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
  20.  
  21.         list.sort(new Comparator<Map.Entry<String, Integer>>() {
  22.             @Override
  23.             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
  24.                 if(o2.getValue() == o1.getValue()) {//出现次数相同的情况下, 按照单词(key)的长度排序
  25.                     if(o1.getKey().length() == o2.getKey().length()) {
  26.                         return o1.getKey().compareTo(o2.getKey());//单词长度相同, 按照字典序升序
  27.                     }
  28.                     return o1.getKey().length() - o2.getKey().length();//按照单词长度升序排
  29.                 }
  30.                 return o2.getValue() - o1.getValue();//按照出现次数降序排
  31.             }
  32.         });
  33.  
  34.         for(int i = 0; i < list.size(); i ++ ) {
  35.  
  36.             for(int j = 0; j < list.get(i).getValue(); j ++ ) {
  37.                 System.out.print(list.get(i).getKey());
  38.                 if (i != list.size() - 1) System.out.print(" ");
  39.             }
  40.         }
  41.  
  42.     }
  43.     public static String arrange(String str) {//单词内部的字典序
  44.         //list可以排字典序
  45.         ArrayList<Character> list = new ArrayList<>();
  46.         for(int i = 0; i < str.length(); i ++ ) {
  47.             list.add(str.charAt(i));
  48.         }
  49.         list.sort(new Comparator<Character>() {
  50.             @Override
  51.             public int compare(Character o1, Character o2) {
  52.                 return o1.compareTo(o2);
  53.             }
  54.         });
  55.         StringBuilder res = new StringBuilder();
  56.         for(char c : list) {
  57.             res.append(c);
  58.         }
  59.         return res.toString();
  60.     }
  61. }

48 MVP争夺战 TODO 要背

这个有点难, dfs

java

  1. import java.util.*;
  2.  
  3. //48 MVP争夺战
  4. public class Main {
  5.  
  6.     static int max = -1;
  7.     static int min = 51;
  8.     static int[] cnt = new int[51];
  9.  
  10.     public static void main(String[] args) {
  11.         Scanner sc = new Scanner(System.in);
  12.  
  13.         int t = sc.nextInt();//有得分的分钟数 [1,50]
  14.  
  15.         int[] scores = new int[t];
  16.  
  17.         int sum = 0;
  18.         for(int i = 0; i < t; i ++ ) {
  19.             scores[i] = sc.nextInt();
  20.             sum += scores[i];
  21.             cnt[scores[i]] ++ ;//得分i 出现几次cnt[i]
  22.         }
  23.  
  24.         Arrays.sort(scores);
  25.         max = scores[t - 1];//最末尾就是最大值
  26.         min = scores[0];//最开头就是最大值
  27.  
  28.         //mvp得分即是 = 总分 / 人数 = 平均分
  29.         //最小平均分 数组的最大值
  30.         //最大平均分 总分, 即所有都是一个人投中的
  31.         // [数组里的最大值, sum / 1]
  32.  
  33.         //按照题意 找最小平均分, 从最小平均分开始遍历, 满足条件则结束
  34.         for(int i = max; i <= sum; i ++ ) {
  35.             if(sum % i == 0) {//mvp平均分 能被 总分 整除 = mvp人数, 才有意义
  36.                 dfs(sum / i, 0, i, max);//dfs(总人数, 当前的分数和0, 目标平均分. 枚举位置?)
  37.             }
  38.         }
  39.  
  40.         System.out.println(sum);
  41.  
  42.     }
  43.  
  44.     public static void dfs(int res, int sum, int target, int p) {
  45.         //人数是0了 说明所有人都被遍历过了, 输出结果
  46.         if(res == 0) {//表示一种情况结束了
  47.             System.out.println(target);
  48.             System.exit(0);
  49.         }
  50.         //当 一个获得的分数sum == 目标平均分target, 遍历其余人
  51.         if(sum == target) {
  52.             dfs(res - 1, 0, target, max);//下一个 
  53.             // dfs(人-1, 该人的分0, 目标分target, 继续从最大开始枚举)
  54.             return;
  55.         }
  56.  
  57.         //i从 最大得分 遍历到 最小得分, 枚举每个数字 选择是否用
  58.         for(int i = p; i >= min; -- i) {
  59.             //如果这个分数是在原数组中存在的 cnt>0 且加上之后 <= 目标分, 就把该数字用掉
  60.             if(cnt[i] > 0 && (i + sum) <= target) {
  61.                 cnt[i] --;//用到该数字 i 
  62.                 dfs(res, sum + i, target, i);//dfs(还是当前人, 当前人的分数, 目标分, 继续从i枚举);
  63.                 cnt[i] ++ ;//放回该数字
  64.                 if(sum == 0 || (sum + i) == target) {
  65.                     break;
  66.                 }
  67.             }
  68.         }
  69.     }
  70. }

49 贪心的商人

java

  1. import java.util.*;
  2.  
  3. //49 贪心的商人
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int number = sc.nextInt();//商品种类
  9.         int days = sc.nextInt();//天数
  10.  
  11.         int[] v = new int[number];
  12.         for(int i = 0; i < number; i ++ ) {
  13.             v[i] = sc.nextInt();//商品i的最大持有量 v[i]
  14.         }
  15.  
  16.         int[][] w = new int[number][days];//第i个商品 的 第j天的价格
  17.         for(int i = 0; i < number; i ++ ) {
  18.             for(int j = 0; j < days; j ++ ) {
  19.                 w[i][j] = sc.nextInt();//
  20.             }
  21.         }
  22.         
  23.         int tmp = 0;
  24.         int res = 0;
  25.         for(int i = 0; i < number; i ++ ) {
  26.             for(int j = 0; j < days - 1; j ++ ) {
  27.                 for(int k = j; k < days; k ++ ) {
  28.                     int sell = w[i][k];
  29.                     int buy = w[i][j];
  30.                     tmp = Math.max((sell - buy) * v[i], tmp);//每个商品的最大利润
  31.                 }
  32.             }
  33.             res += tmp;
  34.             tmp = 0;//换商品的时候置0
  35.         }
  36.  
  37.         System.out.println(res);
  38.  
  39.     }
  40. }

50 核酸检测人员安排

java

这也用不到dp 数学退一下就行了

  1. import java.util.*;
  2.  
  3. //50 核酸检测人员安排
  4. public class Main {
  5.     public static void main(String[] args) {
  6.         Scanner sc = new Scanner(System.in);
  7.  
  8.         int c_num = sc.nextInt();//采样员
  9.         int z_num = sc.nextInt();//志愿者
  10.  
  11.         int[] k = new int[c_num];
  12.         int sum = 0;
  13.         for(int i = 0; i < c_num; i ++ ) {
  14.             k[i] = sc.nextInt();//每个员工的效率
  15.             sum += k[i];
  16.         }
  17.         Arrays.sort(k);//从小到大 按照效率排序
  18.  
  19.         int res = 0;
  20.         //每个都要保证 1个
  21.         if(z_num <= c_num) {//志愿者不足 1倍的采样员
  22.             //从尾到头遍历 基准效率 60-600 m= 6-60
  23.             // 所以分配给个人更好 不需要判断 M > k[i]的情况
  24.             for(int i = c_num - 1; i > c_num - z_num - 1; i -- ) {
  25.                 res += k[i];
  26.             }
  27.         } //每个保证1个
  28.         else if(z_num < c_num * 3) {//志愿者1-3倍 采样员
  29.             int left = z_num - c_num;
  30.             res = sum;
  31.             for(int i = c_num - 1; i > 0; i -- ) {
  32.                 int m = (int) (k[i] * 0.1);
  33.                 if(left >= 3) {
  34.                     res += 3 * m;
  35.                     left -= 3;
  36.                 } else {
  37.                     res += left * m;
  38.                     left = 0;
  39.                 }
  40.             }
  41.  
  42.         } else { //志愿者>= 3倍采样员的时候
  43.             res = (int) (sum * 1.3);
  44.         }
  45.  
  46.         System.out.println(res);
  47.     }
  48. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/174233
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号