AtCoder Beginner Contest 294（abc 294）（A~F）

https://atcoder.jp/contests/abc294

A - Filter
不解释

void solve(){
    int n;
    cin >> n;
    for(int i = 1, k; i <= n; i ++){
        cin >> k;
        if(!(k & 1))
            cout << k << ' ';
    }
}

B - ASCII Art
不解释

void solve(){
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            int k;
            cin >> k;
            if(k == 0)
                cout << '.';
            else cout << (char)('A' + k - 1);
        }
        cout << endl;
    }
}

C - Merge Sequences
题太长了，我解释一下题意吧
给你两个数组$A,B$，然后你把这两个数组放到数组$C$里面，排序后，问你原来$A,B$数组中的数字在$C$中的位置，保证$A,B$中的每一个数字都不一样

void solve(){
    int n, m;
    cin >> n >> m;
    std::vector<int> a(n), b(m), c;
    map<int, int> mp;
    int idx = 0;
    for(auto &i : a) cin >> i, c.pb(i);
    for(auto &i : b) cin >> i, c.pb(i);
    sort(c.begin(), c.end());
    for(auto i : c)
        mp[i] = ++ idx;
    for(auto i : a) cout << mp[i] << ' ';
    cout << endl;
    for(auto i : b) cout << mp[i] << ' ';
    cout << endl;  
}

D - Bank
还是说一下题意

给你一个序列$1\sim N$
给你三个操作：
1，选一个没选过的第一个数字放到集合里面
2，给你 $x$，删除集合里面的 $x$
3，问你集合里面最小的数字

所以全是set的操作，所以直接模拟就行

void solve(){
    int n, q;
    cin >> n >> q;
    int id = 1;
    set<int> s;
    while(q --){
        int st;
        cin >> st;
        if(st == 1 && id <= n){
            s.insert(id ++);
        }
        else if(st == 2){
            int x; cin >> x;
            s.erase(x);
        }
        else{
            cout << *s.begin() << endl;
        }
    }
}

E - 2xN Grid
这个题面也不是很好读

给你$L,N1,N2$，然后给你$(v_{1i},l_{1i})(i=1\sim N1)$和$(v_{2i},l_{2i})(i=1\sim N2)$
（但是很苟的是，这俩$v,l$全给一列了，就很难看）
意味着，从位置1开始，有$l_i$长度的数字全是$v_i$
所以上下两行，就可以表示成数组$a_L$和数组$b_L$
他给了两行，所以就问你，对于$1\sim L$中有多少个位置$j$中，$a_j=b_j$

所以直接双指针指就可以了，把数组$a$变成两维，$a_{i1}$表示当前段的右边界的位置，所以$a_{(i-1)1}+1$也意味着$a_{i1}$的左边界，$a_{i0}$就表示当前段的数字是啥
直接双指针就行了

const int N = 1e5 + 10;
ll a[N][2], b[N][2], cnt;
int n1, n2;
ll L;
 
void solve(){
    cin >> L >> n1 >> n2;
    for(int i = 1; i <= n1; i ++) cin >> a[i][0] >> a[i][1], a[i][1] += a[i - 1][1];
    for(int i = 1; i <= n2; i ++) cin >> b[i][0] >> b[i][1], b[i][1] += b[i - 1][1];
 
    ll ans = 0;
    int id1 = 1, id2 = 1;
    while(id1 <= n1 && id2 <= n2){
        if(a[id1][0] == b[id2][0]){
            ans += min(b[id2][1], a[id1][1]) - max(b[id2 - 1][1], a[id1 - 1][1]);
            if(b[id2][1] > a[id1][1])
                id1 ++;
            else if(b[id2][1] < a[id1][1])
                id2 ++;
            else id1 ++, id2 ++;
        }
        else{
            if(b[id2][1] > a[id1][1])
                id1 ++;
            else if(b[id2][1] < a[id1][1])
                id2 ++;
            else id1 ++, id2 ++;
        }
    }
    cout << ans << endl;
}

F - Sugar Water 2

这个题，我只能说，我想写这个篇题解就是因为这个题
关于浮点数二分的讨论

题意：
两个人
分别有$N,M$杯糖水
糖和水量分别是$a_i,b_i$和$c_i,d_i$
这样就可以算每杯糖水的糖含量了（$\frac{100x}{x+y}\%$）
这样两个人可以选两杯水混合，混合的可能总共有$N\ast M$种
问第$K$大的浓度是多少
精确到小数点后9位

解题思路：
首先，我们知道了每杯水的含糖量和含水量，那么每杯水的糖浓度就是$\frac{100x}{x+y}\%$
所以，两杯水混合后的浓度就是$\frac{100(x_1+x_2)}{(x_1+x_2)+(y_1+y_2)}①$
直观地讲，当我们确定一个$x_1$的时候，当$y_2$不变，$x_2$增加的时候，浓度一定增加

trick1:
假设我们的答案浓度为$k$（小数），那么$k=\frac{x}{x+y}$②
所以$x=\frac{k}{1-k}\ast y$③
根据①式得，$x=x_1+x_2$，$y=y_1+y_2$④
③④结合可知，$(x_1-\frac{k}{1-k}{y}_1)+(x_2-\frac{k}{1-k}{y}_2)=0$⑤
我们可以设$s_1=x_1-\frac{k}{1-k}{y}_1$，$s_2=x_2-\frac{k}{1-k}{y}_2$
所以这样看就非常直观了
这个问题就可以优化为，已知$s_1$，找$s_2$，相加等于0
我们只需要枚举$x_1$，然后把$s_1$记录下来，然后在另一个数组里面找$s_2$就行

但是，现在我们知道的是：我们已知$k$，找对应的$s_1{s}_2$，还是没有解决第$K$大问题
我们需要思考，首先我们确定了$s_1$和$k$，要让$k$增大，$x_2{y}_2$需要满足什么条件
要让$k$增加，首先需要让②等式中$x$和$y$的比例增加，反应在①~⑤中就是，⑤中的等式变成不等式
即$(x_1-\frac{k}{1-k}{y}_1)+(x_2-\frac{k}{1-k}{y}_2)>0$⑥

现在，我们得到了一个结论：当我们确定$s_1$和$k$时，要让$k$增加，就是让$s_1>-s_2$
所以，当我们确定$k$的时候，我们可以把$s_1$求出来然后排序存放在数组$V$中，再遍历另一个数组枚举$s_2$，在$V$中二分出来$s_1\ge -s_2$的下标，把下标求和$sum$，$sum$就表示：对于所有的$s_1{s}_2$，有多少种组合满足其浓度$k^{\prime }<k$，这样第$K$小问题就求出来了，第$K$大问题就可以在每次求完下标的时候用枚举的数组长度$len$减下标

然后就是我们经典的二分求$k$的操作了
代码如下

const int N = 5e4 + 10;
long double a[N], b[N], c[N], d[N];
ll n, m, k;

int check(double mid){
    double x = mid / (1 - mid);
    vector<long double> v;
    for(int i = 1; i <= n; i ++)
        v.pb(a[i] - b[i] * x);
    sort(v.begin(), v.end());
    ll ans = 0;
    for(int i = 1; i <= m; i ++)
        ans += n - (lower_bound(v.begin(), v.end(), - (c[i] - d[i] * x)) - v.begin());
    if(ans >= k)
        return 0;
    return 1;
}

void solve(){
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i ++) cin >> a[i] >> b[i];
    for(int i = 1; i <= m; i ++) cin >> c[i] >> d[i];

    long double l = 0, r = 1;
    while(fabs(l - r) > eps){
        long double mid = (l + r) / 2;
        if(check(mid))
            r = mid;
        else l = mid;
    }
    cout << l * 100 << endl;
}

trick2:
现在我们看到代码了
非常易懂，但是有个疑问，eps我们应该定义为多少
首先：for循环二分
先说一下正确性：我们求mid的过程是$(l+r)/2$所以求30次mid之后，即$2^{-30}<10^{-9}$
通过这种方式可以保证误差小于1e-9
（实测，for40次能过35次会wa）

其次：$eps=10^{-9}$
这个是错的

因为，此时我们精确到1e-9，但是输出的时候我们需要乘100，这样精确度就会达到1e-7了，显然精确度不够

最后：$eps=10^{-11}$
这样就可以解决上述的问题，但是需要long double才可以。

那么开始讨论正确的二分姿势：

关于for循环二分，我只能证明它的正确性，但是它依然是一个不确定的东西，不知道就在哪里奇奇怪怪地卡掉了
所以还得是eps
当我们需要精确到1e-13以内的话，都可以用long double解决二分精度问题，但是当需要更加精确的时候呢？

此时我们需要对整数部分和小数部分分别二分
①先二分整数部分，确定整数部分的值，这样的话，整数部分的精确度可以达到$2^{126}$(1e37左右)
②再对小数部分二分，我们小数部分变成整数，即乘个$10^k$，让小数部分变成整数，再进行二分操作，这小数部分的精度就可以达到$2^{-126}$(1e-37左右)

（G和Ex有时间再更，全是课，要似了）