信息学奥赛初赛天天练-93-CSP-S2023阅读程序3-sort排序、同底对数求和、二分查找、二分答案

2023 CSP-S 阅读程序2

判断题正确填 √，错误填 ⨉ ；除特殊说明外，判断题 1.5 分，选择题 3 分，共计 40 分）

01 #include <vector>
02 #include <algorithm>
03 #include <iostream>
04  
05 using namespace std;
06  
07 bool f0(vector<int> &a, int m, int k) {
08     int s = 0;
09     for (int i = 0, j = 0; i < a.size(); i++) {
10         while (a[i] - a[j] > m) j++;
11         s += i - j;
12     }
13     return s >= k;
14 }
15  
16 int f(vector<int> &a, int k) {
17     sort(a.begin(), a.end());
18  
19     int g = 0;
20     int h = a.back() - a[0];
21     while (g < h) {
22         int m = g + (h - g) / 2;
23         if (f0(a, m, k)) {
24             h = m;
25         }
26         else {
27             g = m + 1;
28         }
29     }
30  
31     return g;
32 }
33  
34 int main() {
35     int n, k;
36     cin >> n >> k;
37     vector<int> a(n, 0);
38     for (int i = 0; i < n; i++) {
39         cin >> a[i];
40     }
41     cout << f(a, k) << endl;
42     return 0;
43 }

假设输入总是合法的且 1≤ai≤10^8,n≤10000,1≤k≤n(n−1)/2，完成下面的判断题和单选题

判断题

1 将第 24 行的 m 改为 m - 1，输出有可能不变，而剩下情况为少 1( )

2 将第 22 行的 g + (h - g) / 2 改为 (h + g) >> 1，输出不变( )

3 当输入为 5 7 2 -4 5 1 -3，输出为 5 ( )

单选题

4 设 a数组中最大值减最小值加 1 为 A，则 f 函数的时间复杂度为( )
A O(nlogA)
B O(n^2logA)
C O(nlog(nA))
D O(nlogn)
5 将第 10 行中的 > 替换为 >=，那么原输出与现输出的大小关系为( )
A 一定小于
B 一定小于等于且不一定小于
C 一定大于等于且不一定大于
D 以上三种情况都不对
6 当输入为 5 8 2 -5 3 8 -12，输出为( )
A 13
B 14
C 8
D 15

2 相关知识点

1) 对数求和

同底的两个对数相加，底数不变真数相乘

例题

log4=2

log8=3

log4 + log8 = log(4*9)=log32=5

2) 二分答案

二分答案顾名思义，它用二分的方法枚举答案，并且枚举时判断这个答案是否可行

直接对答案进行枚举查找，接着判断答案是否合法。如果合法，就将答案二分进一步靠近，如果不合法，就接着二分缩小判断。这样就可以大大的减少时间。

二分中有时可以得可行得答案，但不是最大的，继续向右靠近，求出最大值

 int ans = 1;
 int l = 1,r = 100000;//在1~100000之间的整数枚举 
 while(l <= r){
     int m = l + (r - l) / 2;
     if(check(m)){//满足 则进行向右缩小范围 看看有没有更大的 
         ans = m;//可能多次赋值 最后一定是可能的最大值 
         l = m + 1;
      }else{//不满足缩小边长 向左缩小范围 用更小边长继续尝试 
         r = m - 1;
	  } 
  }

二分查找中间值

/* 向右逼近，如果找到满足条件的数，会继续向右找更大的数，让循环结束
   mid=(left+right)/2 left和right都接近最大值时，可能溢出可以使用下面写法替换
   mid=left + (right-left) / 2;
   可以求满足条件的最大值
*/
    
/* 向左逼近，如果找到满足条件的数，会继续向左找更小的数，让循环结束
   mid=(left+right+1)/2 left和right都接近最大值时，可能溢出可以使用下面写法替换
   mid=left + (right-left+1) / 2;
   可以求满足条件的最小值
*/

二分找边界

//左闭右闭 while left right 最终left=right+1
while(left<=right)  left = mid + 1; right =mid-1;
//左闭右开 while left right 最终left=right
while(left<right)   left = mid + 1; right =mid;
//左开右闭 while left right 最终left=right
while(left<right)   left=mid;       right=mid-1;
//左开右开 while left right 最终left=right-1
while(left+1<right) left=mid;       right=mid;

二分查找时间复杂度

二分查找每次都缩小或扩大为原来的一半，所以也是Olog(n)

3 思路分析

假设输入总是合法的且 1≤ai≤10^8,n≤10000,1≤k≤n(n−1)/2，完成下面的判断题和单选题

判断题

1 将第 24 行的 m 改为 m - 1，输出有可能不变，而剩下情况为少 1( T )

分析

1在二分时，如果是从g=m+1找到答案的，则结果不变 - m时 不是答案 走 else m+1 为答案时
2在二分时，如果找到m为最小答案，h=m-1 ，实际结果会比答案少1
    如果想获取正确结果，结束条件 while (g<=h) g=h+1 即g=m+1 (把前h=m-1再加回来)
根据上述1和2，输出结果可能不变，或者比实际少1，因此正确
        
21     while (g < h) {
22         int m = g + (h - g) / 2;
23         if (f0(a, m, k)) {
24             h = m;
25         }
26         else {
27             g = m + 1;
28         }

2 将第 22 行的 g + (h - g) / 2 改为 (h + g) >> 1，输出不变( T )

分析

g + (h - g) / 2 和 h + g) >> 1
上述取中间数的写法主要区别为第1种会避免一个数接近数据类型的范围时，两个数相加避免溢出
由于输入的1≤ai≤10^8,所以(h+g)最大2*10^8 小于整形的最大取值范围，2*10^10
所以上述改变不影响输出

3 当输入为 5 7 2 -4 5 1 -3，输出为 5 ( T )

分析

5 7
对输入的数进行排序
-4 -3 1 2 5
二分模拟
g=0，h=5-(-4)=9 m=(0+9)/2=4
-3-(-4)=1,1-(-3)=4,2-1=1，5-2=3，5-1=4 共4对，少于7，需要增大范围

 g=5，h=9 m=(5+9)/2=7
 -3-(-4)=1,1-(-3)=4,2-1=1，5-2=3, 1-(-4)=5, 2-(-4)=6,2-(-4)=6,2-(-3)=5,5-(1)=4 共9对，大于7，缩小范围，看是否有更小的满足
 
 g=5，h=7 m=(5+7)/2=6
  -3-(-4)=1,1-(-3)=4,2-1=1，5-2=3, 1-(-4)=5, 2-(-4)=6,2-(-4)=6,2-(-3)=5,5-(1)=4 共9对，大于7，缩小范围，看是否有更小的满足
 g=5，h=6 m=(5+6)/2=5
 -3-(-4)=1,1-(-3)=4,2-1=1，5-2=3, 1-(-4)=5, 2-(-4)=6,2-(-3)=5,5-(1)=4 共8对，大于7，此时g=h 退出循环
 所以输出5

单选题

4 设 a数组中最大值减最小值加 1 为 A，则 f 函数的时间复杂度为( C )
A O(nlogA)
B O(n^2logA)
C O(nlog(nA))
D O(nlogn)

分析

17     sort(a.begin(), a.end());
sort排序，时间复杂度为O(n*logn)

二分为logA，每次调用f0函数，为n，所以时间复杂度为n*logA

n*logn +n*logA = n(logn+logA)=nlog(nA)
所以选C
21     while (g < h) {
22         int m = g + (h - g) / 2;
23         if (f0(a, m, k)) {
24             h = m;
25         }
26         else {
27             g = m + 1;
28         }
29     }

07 bool f0(vector<int> &a, int m, int k) {
08     int s = 0;
09     for (int i = 0, j = 0; i < a.size(); i++) {
10         while (a[i] - a[j] > m) j++;
11         s += i - j;
12     }
13     return s >= k;
14 }

5 将第 10 行中的 > 替换为 >=，那么原输出与现输出的大小关系为( B )
A 一定小于
B 一定小于等于且不一定小于
C 一定大于等于且不一定大于
D 以上三种情况都不对

分析

while (a[i] - a[j] > m) j++; 替换为while (a[i] - a[j] >= m) j++;
等于m的时候不被统计数量，如果正好有这个边界值，可能f0可能变成false，不能找到更小的区间，输出变大
如果没有这个边界值，对结果没有影响
所以原输出值一定小于等于现输出值

6 当输入为 5 8 2 -5 3 8 -12，输出为( B )
A 13
B 14
C 8
D 15

分析

5 8
对输入的数进行排序
-12 -5 2 3 8
二分模拟
g=0，h=8-(-12)=20 m=(0+20)/2=12
-5-(-12)=7,2-(-5)=7,3-2=1,8-3=5, 3-(-5)=8,8-2=6共6对，少于8，需要增大范围

g=13，h=20 m=(13+20)/2=16
-5-(-12)=7,2-(-5)=7,3-2=1,8-3=5, 2-(-12)=14,3-(-12)=15,3-(-5)=8,8-(-5)=13,8-2=6共9对，大于8，需要缩小范围

g=13，h=16 m=(13+16)/2=14
-5-(-12)=7,2-(-5)=7,3-2=1,8-3=5, 2-(-12)=14,3-(-5)=8,8-(-5)=13,8-2=6共8对，大于等于8，需要缩小范围

g=13，h=14 m=(13+16)/2=13
-5-(-12)=7,2-(-5)=7,3-2=1,8-3=5,3-(-5)=8,8-(-5)=13,8-2=6共8对，小于8，此时g=13,h=14,g+1后g=h退出循环
返回g+1=14
所以选B