Codeforces #440.Div.2

Posted 2020-10-12 薛定谔的Submit

A - Search for Pretty Integers

题目大意：

　　给两组数。给一个叫“pretty integer”的定义。

　　如果这个数至少有一位来自第一个数组，又有一位来自第二个数组，那么这个数就是 pretty integer。

　　要求找出最小 pretty integer。

　　输入一行两个整数：n，m。分别代表接下来的两个数组大小（n，m ∈ [1,9]）。

　　输入一行n 个整数：代表第一个数组（n[i] ∈ [1,9]）。

　　输入一行m 个整数：代表第二个数组（m[i] ∈ [1,9]）。

　　输出一行一个整数：代表所得出的最小 pretty integer。

　　样例输入：2 3　　　　　　8 8

　　　　　　　4 2　　　　　　1 2 3 4 5 6 7 8

　　　　　　　5 7 6　　　　　8 7 6 5 4 3 2 1

　　样例输出：25　　　　　　 1

解题思路：

　　暴力查询组合所有符合题意的数，不断更新最小值，如果组合出11的倍数，最小值更新成1，2，3...等等。

A C 代码：

 1 import java.util.*;
 2 
 3 public class Main{
 4     public static void main(String[] args){
 5         Scanner sc = new Scanner(System.in);
 6         while(sc.hasNext()){
 7             int n = sc.nextInt();
 8             int m = sc.nextInt();
 9             int a[] = new int[n];
10             int b[] = new int[m];
11             for(int i = 0;i < n;i ++){
12                 a[i] = sc.nextInt();
13             }
14             for(int i = 0;i < m;i ++){
15                 b[i] = sc.nextInt();
16             }
17             Arrays.sort(a);
18             Arrays.sort(b);
19             int ans = 10000000;
20             for(int i = 0;i < n;i ++){
21                 for(int j = 0;j < m;j ++){
22                     if(a[i] == b[j]){ans = Math.min(ans,a[i]);  }
23                     ans = Math.min(ans,Math.min(a[i],b[j]) * 10 + Math.max(a[i],b[j]));
24                 }
25             }
26             System.out.println(ans);
27         }
28     }
29 }

View Code

B - Maximum of Maximums of Minimums

题目大意：

　　给出一组数，将这组数分割成若干个集合。

　　求出每个集合中的最小值的最大值的最大可能值。

　　输入一行两个整数：n，k。n代表接下来有n个数，k代表恰好分成若干个区间（1 <= k <= n <= 1e5）。

　　输入一行n 个整数：代表被分割的集合（每个数字 ∈ [-1e9,1e9]）。

　　输出一行一个整数：代表得出的最大值。

　　样例输入：5 2　　　　　　5 1

　　　　　　　1 2 3 4 5　　　-4 -5 -3 -2 -1

　　样例输出：5　　　　　　　-5

解释样例：

　　第一个集合被拆分成两个有如下可能：

　　可以被拆分成{1}{2，3，4，5}，最大值是2；

　　可以被拆分成{1，2}{3，4，5}，最大值是3；

　　可以被拆分成{1，2，3}{4，5}，最大值是4；

　　可以被拆分成{1，2，3，4}{5}，最大值是5；

　　所以输出5。

解题思路：

　　本题稍作思考，即可发现规律。

　　正好被分成一个集合，最大值就是这组数据的最小值。

　　大于等于3个集合，最大值就是这组数据的最大值。

　　只需将最大值独立出来，剩下的集合分成两个集合，就能得到这个答案。

　　若恰好分成两个集合，从解释样例一可以看出，只需要比较这组数据的第一个值与最后一个值，然后输出这两个中的较大值即可。

A C 代码：

 1 import java.util.*;
 2 
 3 public class Main{
 4     public static void main(String[] args){
 5         Scanner sc = new Scanner(System.in);
 6         while(sc.hasNext()){
 7             int n = sc.nextInt();
 8             int k = sc.nextInt();
 9             int m[] = new int[n];
10             int max = -1000000002;
11             int min = 1000000002;
12             for(int i = 0;i < n;i ++){
13                 m[i] = sc.nextInt();
14                 if(m[i] > max){max = m[i];}
15                 if(m[i] < min){min = m[i];}
16             }
17             if(k == 1){System.out.println(min);}
18             else if(k == 2){System.out.println(Math.max(m[0],m[n - 1]));}
19             else{System.out.println(max);}
20         }
21     }
22 }

View Code

C - Maximum splitting

题目大意：

　　求任意一个数能否被分成若干个合数的和（合数，即非素数，不包括1和0）。若能，输出最多能分割的数量，若不能输出 -1。

　　输入一行一个整数：q，代表共有多少个数被判断（q ∈ [1，1e5]）。

　　输入q 行q 个整数：每个数都进行上述计算（q[i] ∈ [1，1e9]）。

　　输出q 行q 个整数：代表得出的结果。

　　样例输入：1　　　　　　2　　　　　　3

　　　　　　　12　　　　　 6　　　　　　1

　　　　　　　　　　　　　 8　　　　　　2

　　　　　　　　　　　　　　　　　　　　3

　　样例输出：3　　　　　　1　　　　　　-1

　　　　　　　　　　　　　 2　　　　　　-1

　　　　　　　　　　　　　　　　　　　　-1

解题思路：

　　根据样例，1，2，3都输出 -1。

　　要想拆分的最多，应该保证每个合数都尽可能小。

　　因为最小的合数是4，最小的奇数和数是9，但是不是所有偶数都能被4整除，所以需要引进第二个合数6。

　　然后思路十分明确，奇数先减9，然后一直减6直到剩下的数能被4整除。偶数则不需要减9，直接进行后面的计算。

A C 代码：

 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         while(sc.hasNext()){
 8             int n = sc.nextInt();
 9             for(int I = 0;I < n;I ++){
10                 int ans = 0;
11                 int t = sc.nextInt();
12                 if(t <= 3){System.out.println("-1");}
13                 else if(t == 5 || t == 7 || t == 11){System.out.println("-1");}
14                 else{
15                     if(t % 2 == 1){t = t - 9;ans ++;}
16                     while(t % 4 != 0){
17                         t = t - 6;
18                         ans ++;
19                     }
20                     ans = ans + t / 4;
21                     System.out.println(ans);
22                 }
23             }
24         }
25     }
26 }

View Code