CCF认证期末预测之最佳阈值

期末预测之最佳阈值

题目描述

具体来说，顿顿评估了$m$位同学上学期的安全指数，其中第$i(1\le i\le m)$位同学的安全指数为$y_i$，是一个$[0,10^8]$范围内的整数；同时，该同学上学期的挂科情况记作 r e s u l t i ∈ { 0 , 1 } result_i\in \{0,1\} resulti​∈{0,1}，其中$0$表示挂科、$1$表示未挂科。

相应地，顿顿用$predic{t}_{\theta }(y)$表示根据阈值$\theta$将安全指数$y$转化为的具体预测结果。 如果$predic{t}_{\theta }(y_j)$与$resul{t}_j$相同，则说明阈值为$\theta$时顿顿对第$j$位同学是否挂科预测正确；不同则说明预测错误。

$$predic{t}_{\theta }(y)=\{\begin{array}{ll}0& (y<\theta )\\ 1& (y\ge \theta )\end{array}$$
最后，顿顿设计了如下公式来计算最佳阈值${\theta }^{\ast }$
$${\theta }^{\ast }=\max \underset{\theta \in y_i}{\mathrm{argmax}}\sum _{j=1}^m(predic{t}_{\theta }(y_j)==resul{t}_j)$$

该公式亦可等价地表述为如下规则：

最佳阈值仅在$y_i$中选取，即与某位同学的安全指数相同；
按照该阈值对这$m$位同学上学期的挂科情况进行预测，预测正确的次数最多（即准确率最高）；
多个阈值均可以达到最高准确率时，选取其中最大的。

输入格式

从标准输入读入数据。

输入的第一行包含一个正整数$m$。

接下来输入$m$行，其中第$i(1\le i\le m)$行包括用空格分隔的两个整数$y_i$和$resul{t}_i$，含义如上文所述。

输出格式

输出到标准输出。

输出一个整数，表示最佳阈值${\theta }^{\ast }$。

样例1输入

6
0 0
1 0
1 1
3 1
5 1
7 1

样例1输出

3

样例1解释

按照规则一，最佳阈值的选取范围为$0,1,3,5,7$。

$\theta =0$时，预测正确次数为$4$；

$\theta =1$时，预测正确次数为$5$；

$\theta =3$时，预测正确次数为$5$；

$\theta =5$时，预测正确次数为$4$；

$\theta =7$时，预测正确次数为$3$。

阈值选取为$1$或$1$时，预测准确率最高； 所以按照规则二，最佳阈值的选取范围缩小为$1,3$。

依规则三， θ ∗ = max ⁡ { 1 , 3 } = 3 \theta^*=\max\{1,3\}=3 θ∗=max{1,3}=3。

样例2输入

8
5 1
5 0
5 0
2 1
3 0
4 0
100000000 1

样例2输出

100000000

子任务

$70\%$的测试数据保证$m\le 200$；

全部的测试数据保证$2\le m\le 10^5$。

思路

注意到此题可以化简思路：对于数组$a$中的每个值$key$，求出在 r e s u l t ∈ { 0 , 1 } result\in \{0, 1\} result∈{0,1}时，$y\ge key$和$y<key$的元素个数。

暴力法：

当$key$只有一个值时，很容易查找，只需要遍历一遍数组即可解决，所以暴力法的思路是对每个$key$进行枚举。
两层循环，外循环枚举每一个值，内循环遍历每一个数据判断是否满足$predict==result$，进行了两层循环，时间复杂度为$O(n^2)$。
数据量到了$10^5$级别，$O(n^2)$显然时间会爆掉。

优化算法

一般$10^5$数据量都会用$O(n\log n)$的时间复杂度，所以考虑排序算法。
排序后有两个问题：

1. $result=0$和$result=1$处理方式不同，所以将两种情况单独存储，将$result=0$和$result=1$的数据用两个$vector$分开存储。
2. 排序完的操作：采用二分查找即可

排序的时间复杂度为$O(n\log n)$，对每个元素枚举后进行一次二叉查找为$O(n\log n)$，则时间复杂度为$O(n\log n)$

#include <bits/stdc++.h>
using namespace std;
vector<int> a[2];
int ans, m, x, y, val;
int main() {
    scanf("%d", &m);
    for(int i = 1; i <= m; i++) scanf("%d %d", &x, &y), a[y].push_back(x);
    for(int i = 0; i < 2; i++) sort(a[i].begin(), a[i].end());
    for(int i = 0; i < 2; i++) {
        int len = a[i].size();
        for(int j = 0; j < len; j++) {
            int s = (lower_bound(a[0].begin(), a[0].end(), a[i][j]) - a[0].begin()) + (a[1].size() - (lower_bound(a[1].begin(), a[1].end(), a[i][j]) - a[1].begin()));
            if(s > val || (s == val && a[i][j] > ans)) {
                val = s;
                ans = a[i][j];
            }
        }
    }
    printf("%d", ans);
    return 0;
}

前缀和做法

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
unordered_map<int, bool> ext;
pair<int, int> a[maxn];
int n, x, y, s[maxn], ans, Max;
int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d %d", &x, &y), a[i] = make_pair(x, y);
    sort(a + 1, a + 1 + n);
    for(int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i].second;
    for(int i = 1; i <= n; i++) {
        if(ext[x = a[i].first]) continue;
        ext[x] = true;
        int val = s[n] + i - 1 - 2 * s[i - 1];
        if(val >= Max) {
            Max = val;
            ans = x;
        }
    }
    printf("%d", ans);
    return 0;
}