2022 年牛客多校第四场补题记录

A Task Computing

题意：给定长度为 $n$ 的序列 $\{(w_i,p_i)\}$，从中选出 $m$ 项并重新排列得到子序列 { a 1 , a 2 , ⋯   , a m } \{a_1,a_2,\cdots,a_m\} {a1​,a2​,⋯,am​}，最大化 $\sum _{i=1}^m{w}_{a_i}\prod _{j=1}^i{p}_{a_j}$。$n\le 1\times 10^5$，$m\le 20$，$p_i\in [0.8,1.2]$。

解法：如果选出的元素给定为子序列 $\{(w_i,p_i)\}$，考虑如何贪心。使用常见的相邻局部调整法证明贪心：交换相邻两个元素 $(w_i,p_i)$ 与 $(w_{i+1},p_{i+1})$，对最终答案的影响只会与 $w_i$ 与 $w_{i+1}$ 的系数有关。原始系数为 $a=w_i\prod _{j=1}^i{p}_j+w_{i+1}\prod _{j=1}^{i+1}{p}_j$，改变后系数为 $b=\frac{w_{i+1}}{p_i}\prod _{j=1}^{i+1}{p}_j+w_i\prod _{j=1}^{i+1}{p}_j$。令 $a-b=\left(\prod _{j=1}^{i-1}{p}_j\right)(w_i{p}_i+w_{i+1}{p}_i{p}_{i+1}-w_{i+1}{p}_{i+1}-w_i{p}_i{p}_{i+1})>0$，则 $w_i(p_{i+1}-1)<w_{i+1}(p_i-1)$。因而贪心规则为 $w_i(p_{i+1}-1)$。

按照这一贪心排序，那么选择的元素必然按此顺序。为了便于计算，可以用秦九韶算法对上式进行倒序计算。设 $f_{i,j}$ 为倒序遍历到第 $i$ 个元素，已经选择了 $j$ 个元素的最大值，则有 $f_{i,j}\leftarrow \max (f_{i+1,j},f_{i+1,j-1}{p}_i+w_i)$。总时间复杂度 $\mathcal{O}(n\log n+nm)$。

#include <bits/stdc++.h>
using namespace std;
const long double inf = 1e12;
struct node
{
    long long w;
    long double p;
    bool operator<(const node &b)const
    {
        return w * (b.p - 1) < b.w * (p - 1);
    }
};
const int N = 100000;
node que[N + 5];
long double f[N + 5][25];
int main()
{
    int n, m, p;
    long long w;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n;i++)
        scanf("%lld", &que[i].w);
    for (int i = 1; i <= n;i++)
    {
        scanf("%d", &p);
        que[i].p = 1.0 * p / 10000;
    }
    sort(que + 1, que + n + 1);
    f[n + 1][0] = 0;
    for (int i = 1; i <= m; i++)
        f[n + 1][i] = -inf;
    for (int i = n; i >= 0; i--)
        for (int j = 0; j <= m; j++)
        {
            f[i][j] = f[i + 1][j];
            if (j)
                f[i][j] = max(f[i][j], que[i].w + que[i].p * f[i + 1][j - 1]);
        }
    printf("%.12Lf\n", f[1][m]);
    return 0;
}

B 2D Internet Angel

题意：给定内外同心圆，半径分别为 $R_1,R_2$，沿内侧圆外有一 $n$ 边外接多边形 { P i } \{P_i\} {Pi​}，与内侧圆的切点为 { Q i } \{Q_i\} {Qi​}，保证这一多边形完全在外侧圆内。记此外接多边形外与外侧圆内侧部分的点到多边形和内侧圆切点的最近距离为 $X$，求 $E(X^2)$。$n\le 1\times 10^5$。

解法：过凸包顶点 $P_i(x_i,y_i)$ 和 $P_{i+1}(x_{i+1},y_{i+1})$ 的中点 $Q_i$，和外侧圆弧（即 $F{P}_2{Q}_{2}E$）所包络区域内的点的最近距离是到 $Q_i$ 点的距离。记 $P_i$ 极角为 ${\beta }_i$，$Q_i$ 极角为 ${\alpha }_i$，设一点位于 $U(x,y)$，则利用 $\Delta UOQ$ 的余弦定理，设 $\angle P_{i}OU=\theta$，$\angle UO{Q}_i={\alpha }_i-{\beta }_i-\theta$，则有 $U{Q}_2^2=O{U}^2+O{Q}_2^2-2OU\cdot O{Q}_2\cos ({\alpha }_i-{\beta }_i-\theta )$，因而只与 $OU=r$ 和极角 $\theta$ 有关，因而可以利用极坐标下二重积分，计算出对于 $Q_i$ 答案为：
$$g_i=2{\int }_0^{{\alpha }_i-{\beta }_i}\mathrm{d}\theta {\int }_{R_1\sec ({\alpha }_i-{\beta }_i-\theta )}^{R_2}(R_1^2+r^2-2R_{1}r\cos ({\alpha }_i-{\beta }_i-\theta ))r\mathrm{d}r$$

二倍的原因在于 $\angle P_{i}O{Q}_i=\angle Q_{i}O{P}_{i+1}$。

考虑计算如下的二重积分：
$$\begin{array}{rl}f(\alpha )=& {\int }_0^{\alpha }\mathrm{d}\theta {\int }_{R_1\sec \theta }^{R_2}(R_1^2+r^2-2R_{1}r\cos \theta )r\mathrm{d}r\\ =& {\int }_0^{\alpha }\mathrm{d}\theta {\left(\frac{R_1^2{r}^2}{2}+\frac{1}{4}{r}^4-\frac{2R_1{r}^3}{3}\cos \theta \right)|}_{R_1\sec \theta }^{R_2}\\ =& \alpha \left(\frac{R_1^2{R}_2^2}{2}+\frac{1}{4}{R}_2^4\right)-\frac{R_1^4}{4}{\int }_0^{\alpha }2{\sec }^2\theta +{\sec }^4\theta \mathrm{d}\theta -\frac{2R_1{R}_2^3}{3}{\int }_0^{\alpha }\cos \theta \mathrm{d}\theta +\frac{2R_1^4}{3}{\int }_0^{\alpha }{\sec }^2\theta \mathrm{d}\theta \\ =& \alpha \left(\frac{R_1^2{R}_2^2}{2}+\frac{1}{4}{R}_2^4\right)-\frac{R_1^4\tan \alpha }{12{\cos }^2\alpha }-\frac{2}{3}{R}_1{R}_2^3\sin \alpha \end{array}$$
因而可以 $\mathcal{O}(1)$ 的计算出每个 $Q_i$ 的答案。最后只需要使用直线与直线的交算出 $P_i$，得到凸多边形 C = { P n } C=\{P_n\} C={Pn​} 然后求出其面积 $S$，答案为 $\frac{{\sum }_{i=1}^n{g}_i}{\pi R_2^2-S_C}$。

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int n;
        scanf("%d%Lf%Lf", &n, &r1, &r2);
        vector<Point> Q(n), P(n);
        vector<int> angQ(n);
        for (int i = 0, x; i < n;i++)
        {
            scanf("%d", &x);
            angQ[i] = x;
            Q[i].x = r1 * cosl(x * PI / 10000);
            Q[i].y = r1 * sinl(x * PI / 10000);
        }
        for (int i = 0; i < n;i++)
        {
            Line now;
            now.p = Q[i];
            now.v = (Point){-Q[i].y, Q[i].x};
            Line nx;
            nx.p = Q[(i + 1) % n];
            nx.v = (Point){-Q[(i + 1) % n].y, Q[(i + 1) % n].x};
            P[i] = nx.inter(now);
        }
        auto inner = convexhull(P);
        auto cal_ang = [&](int id)
        {
            return atan2l(P[id].y, P[id].x);
        };
        long double ans = 0;
        for (int i = 0; i < n;i++)
        {
            long double nowQ = angQ[i] * PI / 10000;
            long double prevP = cal_ang((i + n - 1) % n);
            long double nowP = cal_ang(i);
            while(prevP > nowQ)
                prevP -= PI;
            while(nowP < nowQ)
                nowP += PI;
            ans += f(nowP - nowQ) + f(nowQ - prevP);
        }
        printf("%.15Lf\n", ans / (r2 * r2 * PI - inner.area() / 2));
    }
    return 0;
}

C Easy Counting Problem

题意：给定字符集大小 $\Sigma$，和每个字符出现次数的下限 { c i } \{c_i\} {ci​}，$q$ 次询问由 $\Sigma$ 中字符构成的长度为 $n$ 的字符串的个数。$q\le 300$，$n\le 1\times 10^7$，$\sum c_i\le 5\times 10^4$，$|\Sigma |\le 10$。

解法：对于 $\sum c_i$ 较小的约束条件，可以考虑使用生成函数。本题中由于有次数限制并且对排列计数，因而使用 EGF 指数生成函数。对于第 $i$ 个字符，其方案对应的 EGF 为
$$\sum _{j=c_i}^{+\infty }\frac{x^j}{j!}=e^x-\sum _{j=0}^{c_i-1}\frac{x^j}{j!}$$
因而对于给定长度的 $n$，其答案为 $n![x^n]\prod _{i=1}^{|\Sigma |}\sum _{j=c_i}^{+\infty }\frac{x^j}{j!}$。考虑如何快速计算：
$$\begin{array}{rl}\prod _{i=1}^{|\Sigma |}\sum _{j=c_i}^{+\infty }\frac{x^j}{j!}=& \prod _{i=1}^{|\Sigma |}\left(e^x-\sum _{j=0}^{c_i-1}\frac{x^j}{j!}\right)\\ =& \sum _{i=0}^{|\Sigma |}(-1{)}^{|\Sigma |-i}{e}^{ix}\left(\prod _{j\in S,|S|=|\Sigma |-i}\sum _{k=0}^{c_j-1}\frac{x^k}{k!}\right)\end{array}$$
其中 $S\in \Sigma$。但是直接计算上式是需要计算 $O(|\Sigma |2^{|\Sigma |})$ 次多项式相乘，不够优秀。但是注意到这一形式与 01 背包非常相似，因而使用背包形式的转移：$f_{i,j}$ 表示截止前 $i$ 个字符，已经乘了 $j$ 个多项式的多项式。其转移形式为 $f_{i,j}\leftarrow f_{i-1,j}+f_{i-1,j-1}g(j)$，其中 $g(j)=\sum _{k=0}^{c_j-1}\frac{x^k}{k!}$。 这样只需要计算 $\mathcal{O}(|\Sigma {|}^2)$ 次多项式乘法计算。

因而预处理出 $f_{|\Sigma |,i},i\in [0,|\Sigma |]$ 后，容易注意到 $g$ 的次数仅为 $\sum c_i$。对于第 $n$ 项，其答案来源为 $e^{(|\Sigma |-i)x}$ 的第 $n-k$ 项与 $f_{|\Sigma |,i}$ 的第 $k$ 项的系数乘积和，即 $\sum _{k=0}^{\sum c_i}\sum _{i=0}^{|\Sigma |}(-1{)}^{|\Sigma |-i}\frac{n!(|\Sigma |-i{)}^{n-k}}{(n-k)!}([x^k]f_{|\Sigma |,i})$。

因而总的复杂度为 $\mathcal{O}(|\Sigma {|}^2\sum c_i\log \sum c_i+q|\Sigma |\sum c_i)$。

void Solve() {
    scanf("%d", &m);
    vector<Poly> p(m + 1);
    p[0] = {1};
    for (int i = 0, x; i < m; ++i) {
        scanf("%d", &x);
        Poly c = Poly(ifac, ifac + x);
        for (int j = i + 1; j; --j)
            p[j] += p[j - 1] * c;
    }
    scanf("%d", &q);
    while (q--) {
        int n, ans = 0;
        scanf("%d", &n);
        if (n < p[m].size()) {
            puts("0");
            continue;
        }
        for (int k = 0; k <= m; ++k) {
            int res = 0;
            for (int i = (int)p[k].size() - 1, pw = POW(m - k, n - i); ~i; --i) {
                res = (res + (ll)p[k][i] * pw % P * ifac[n - i]) % P;
                pw = (ll)pw * (m - k) % P;
            }
            inc(ans, k & 1 ? P - res : res);
        }
        printf("%lld\n", (ll)ans * fac[n] % P);
    }
}

D、E Jobs

题意：有 $n$ 家公司，第 $i$ 家公司有 $m_i$ 个工作，对能力要求为 $(a_j,b_j,c_j)$，其中 $1\le a_j,b_j,c_j\le 400$。若候选者能力值为 $(x,y,z)$ 满足有一个工作符合 $x\ge a_j,y\ge b_j,z\ge c_j$，则认为该候选者可以被该公司录用。$q$ 次询问，每次给定一个候选者的能力值，问能被几个公司录用。D 题 $ n \leq 10$，E 题 $n\le 1\times 10^6$，$q\le 2\times 10^6$。

解法：显然一个朴素思路为维护第 $i$ 家公司对前两个能力要求分别为 $x,y$ 时，最少需要多少的 $z$ 才能录用。这样进行二维前缀和即可，复杂度 $\mathcal{O}(n{m}^2+q)$。但是这样无法通过 E 题。

考虑如果只有两维的能力值 $(a_i,b_i)$ 要求，考虑二位数点模型。首先根据 $a_i$ 从小到大排序，把完全包络的职位（$a_i\le a_j,b_i\le b_j$）删除，则一定可以得到如下的阶梯状前缀和。

为了让一个公司对前缀和的影响至多只有 $1$——即一个公司如果有多个职位对候选者符合，在前缀和矩阵上的值也只有 $1$，绿点表示增加 $1$，红点表示减少 $1$，下方的矩形右上端点为 $(a_i,b_i)$。灰色区域表示该公司可以对哪些候选者发出 offer。记录该数组为 $p_{i,j}$。

考虑插入和删除一个职位会发生什么，以中间的矩形 $(a_i,b_i)$ 为例。

1. 插入：$p_{a_i,b_i}$ 增加，$p_{a_i,b_{i-1}}$ 减少，$p_{a_{i+1},b_i}$ 减少。
2. 删除：$p_{a_i,b_i}$ 减少，$p_{a_i,b_{i-1}}$ 和 $p_{a_{i+1},b_i}$ 补回来。

其操作类似于链表。

接下来考虑第三维的影响。对每个职位按照 $c_i$ 从小到大进行排序，然后考虑分层进行，对于每一层内部和回归到这一二维问题，逐层职位堆叠起来。加入第三维且按从小到大顺序之后，对于第 $i$ 个职位，考虑类似单调队列的想法：

1. 若已经存在的矩形（职位）满足 $a_j\ge a_i$ 且 $b_j\ge b_i$，则对于 $z\ge c_i$ 的人，$j$ 工作已经完全被 $i$ 顶死了，弹出 $j$；
2. 若存在矩形满足 $a_j\le a_i$ 且 $b_j\le b_i$，则当前这个职位被 $j$ 职位顶掉了，不需要加入。

因而对于一家公司，可以 $\mathcal{O}(m\log m)$ 的预处理出 $p$ 数组，然后进行 $\mathcal{O}(c^3)$ 的前缀和即可。每次询问可以做到 $\mathcal{O}(1)$，总复杂度 $\mathcal{O}(nm\log m+c^3+q)$。

void dele(multiset<hh>::iterator pos,int h){
    --pre[pos->a][pos->b][h];
    if(pos==st.begin()){
        if(pos!=--st.end()){
            it1=pos,++it1;
            ++pre[it1->a][pos->b][h];
        }
    }
    else if(pos==--st.end()){
        it1=pos,--it1;
        ++pre[pos->a][it1->b][h];
    }
    else{
        it1=it2=pos,--it1,++it2;
        ++pre[pos->a][it1->b][h],
        ++pre[it2->a][pos->b][h],
        --pre[it2->a][it1->b][h];
    }
    st.erase(pos);
}
void ins(hh x){
    it=st.insert(x);
    ++pre[x.a][x.b][x.c];
    if(it==st.begin()){
        if(++it!=st.end()) --pre[it->a][x.b][x.c];
    }
    else if(it==--st.end()){
        if(it!=st.begin()) --it,--pre[x.a][it->b][x.c];
    }
    else{
        it1=it,--it1,it2=it,++it2;
        ++pre[it2->a][it1->b][x.c];
        --pre[it2->a][it->b][x.c];
        --pre[it->a][it1->b][x.c];
    }
}
IL int chk(hh x){
    it=st.upper_bound(x);
    if(it!=st.end()){if(it->b>=x.b){dele(it,x.c);return 0;}}
    if(it!=st.begin()){if((--it)->b<=x.b){flag=0;return 1;}}
    return 1;
}
int main()
{
    n=in(),q=in();
    for(int i=1;i<=n;++i){
        int k=in();
        for(int j=1;j<=k;++j)
          a[j]=(hh){in(),in(),in()};
        st.clear(),sort(a+1,a+k+1,cmp1);
        for(int j=1;j<=k;++j){
            flag=1;while(!chk(a[j]));
            if(flag) ins(a[j]);
        }
    }
    for(int i=1;i<=M;++i)
      for(int j=0;j<=M;++j)
        for(int k=0;k<=M;++k)
          pre[i][j][k]+=pre[i-1][j][k];
    for(int i=0;i<=M;++i)
      for(int j=1;j<=M;++j)
        for(int k=0;k<=M;++k)
          pre[i][j][k]+=pre[i][j-1][k];
    for(int i=0;i<=M;++i)
      for(int j=0;j<=M;++j)
        for(int k=1;k<=M;++k)
          pre[i][j][k]+=pre[i][j][k-1]; 
    int ans=0,lastans=0,seed=in();
    std::mt19937 rng(seed);
    std::uniform_int_distribution<> u(1,400);
    while(q--){
        int IQ=(u(rng)^lastans)%400+1;
        int EQ=(u(rng)^lastans)%400+1;
        int AQ=(u(rng)^lastans)%400+1;
        ans=(1ll*ans*seed%p+(lastans=pre[IQ][EQ][AQ]))%p;
    }
    printf("%d\n",ans);
    return 0;
}

H Wall Builder II

题意：给定 $n$，长度为 $1\times i$ 的砖块有 $n-i+1$ 个。现将这些砖拿来砌墙，不允许旋转（只能 $1\times i$ 的放置）且要密铺，且要求砌成的墙为矩形，问这个大矩形的最小周长。$n\le 100$。

解法：面积 $S=\sum _{i=1}^{n}i(n-i+1)$。因而枚举长宽 $h,w$，贪心的从大到小的将 $1\times w$ 的区域填砖块，填满 $h$ 次即可。可以证明这样贪心对 $n\le 100$ 成立。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int t, n;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        int s = 0;
        for (int i = 1; i <= n;i++)
            s += i * (n - i + 1);
        vector<pair<pair<int, int>, pair<int, int>>> put;
        function<bool(int, int)> check = [&](int w, int h)
        {
            put.clear();
            vector<int> cnt(n + 1);
            for (int i = 1; i <= n;i++)
                cnt[i] = n - i + 1;
            for (int times = 0; times < h; times++)
            {
                int last = w;
                while(last)
                {
                    bool flag = 0;
                    for (int j = min(n, last); j >= 1;j--)
                        if(cnt[j])
                        {
                            put.emplace_back(make_pair(times, w - last), make_pair(times + 1, w - last + j));
                            flag = 1;
                            last -= j;
                            cnt[j]--;
                            break;
                        }
                    if (!flag)
                        return false;
                }
            }
            return true;
        };
        int ans = 0;
        for (int i = sqrt(s); i >= 1;i--)
            if (s % i == 0 && (check(i, s / i) || check(s / i, i)))
            {
                ans = 2 * (i + s / i);
                break;
            }
        printf("%d\n", ans);
        for (auto i : put)
            printf("%d %d %d %d\n", i.first.second, i.first.first, i.second.second, i.second.first);
    }
    return 0;
}

J Counting Fish Again

题意：在第一象限含坐标轴的无穷大方格纸上，可以画一条斜率为 $-1$ 的线段 $(u_1,v_1)\to (u_2,v_2)$，或者擦除已经有的一条线段，问每次操作后鱼的个数。鱼形状如下：

操作次数 $q$ 满足 $q\le 1\times 10^6$。

解法：对于每一个截距的直线单独考虑，利用珂朵莉树的方法维护每条直线上的最长连续线段，只需要对每个最长连续线段所对应的鱼进行计数即可。注意到鱼尾和鱼身的连接点可以唯一确定一条鱼，因而对这一连接点进行讨论。

首先考虑鱼头朝下的情况。这种情况复杂在于鱼头可能会超出坐标格。假定鱼尾和鱼身的连接点 $P$ 为 $(x_0,y_0)$，此时所画斜线方程为 $l:x+y=B$，斜线线段为 $(u_1,v_1)\to (u_2,v_2)$。考虑 $P$ 关于 $l$ 的对称点 $P^{\prime }(x_1,y_1)$ 有 $y_0-x_0=y_1-x_1$，且 $x_1+y_1+x_0+y_0=2B$，可得 $P^{\prime }(B-y_0,B-x_0)$。则鱼头 $Q$ 和 $P^{\prime }$ 的中点即为 $P$，因而有 $Q(2x_0+y_0-B,2y_0+x_0-B)$ 且满足 $Q$ 在第一象限。因而 $2x_0+y_0\ge B,2y_0+x_0\ge B$。此外还有限制 $x_0\in [u_1,u_2],y_0\in [v_1,v_2],x_0+y_0\le B$。

考虑对于以上的限制进行计算合法的格点数。首先仅考虑 $x=u_1,y=v_2,x+y=B$ 围成的区域，点数为 $\frac{1}{2}(u_2-u_1)(u_2-u_1-1)$。接下来考虑 $2x+y=B$ 和 $x+2y=B$。

对于 $2x+y=B$，情况如下：

$D(u_1,B-2u_1)$，$E\left(\frac{B-v_2}{2},v_2\right)$，因而 $\Delta ADE$ 根据 $E$ 是否为整点可以得到其覆盖点数为

1. $E$ 整点：$\frac{1}{2}(B-2u_1-v_2+2{)}^2$；
2. $E$ 不是整点：$\frac{1}{2}(B-2u_1-v_2+1)(B-2u_1-v_2+3)$。

同理 $x+2y=B$ 的情况为 $D\left(u_1,\frac{B-u_1}{2}\right)$ ，$E(B-2v_2,v_2)$。此时根据 $D$ 是否为整点可以计算出 $\Delta ADE$ 覆盖点数为

1. $D$ 为整点：$\frac{1}{2}(B-2v_2-u_2+2{)}^2$；
2. $D$ 不为整点：$\frac{1}{2}(B-2v_2-u_2)(B-2v_2-u_2+3)$。

接下来考虑两条线交叠的下方不规则区域：

将区域拆分为 $AFGH$ 和 $\Delta GHE$。$G$ 坐标为 $\left(\frac{B}{3},\frac{B}{3}\right)$，首先将 $GH$ 向右平移至横坐标为一整点后，计算出 $GH$ 的长 $B-2\lceil \frac{B}{3}\rceil +1$ 后 $\Delta GHE$ 部分和上面问题等同；同时，$GHAF$ 范围内的整点数可以由 $\Delta FAI$ 中整点数目减去 $\Delta GHI$ 中个数得到。或者使用 Pick 定理也可。

对于直线上侧的点，无限制，答案为 $\frac{1}{2}(u_2-u_1)(u_2-u_1-1)$。因而对于一条给定的线段都可以实现 $\mathcal{O}(1)$ 的计算合法的鱼数目。

插入一条边时，需要考虑 $(u_1,v_1)$ 左侧是否有一条线段末端在 $(u_1,v_1)$，右侧同理。首先进行延申，去除旧线段然后插入延申后的新线段。对删除，找到目标线段，该目标线段一定是完全覆盖删除段的。这时等效于先把目标线段删除，再插入两端未删除部分。总复杂度为珂朵莉树的 $\mathcal{O}(q\log q)$。

#include <bits/stdc++.h>
using namespace std;
long long ans;
const long long inf = 0x3f3f3f3fll;
class Chtholly
{
    long long sum;
    long long S(long long l, long long r)
    {
        if (l > r)
            return 0;
        long long ss = (sum + l + sum + r) * (r - l + 1) / 2;
        long long mod2 = 0;
        long long K = max(0ll, (r - l + 1) / 2 - 1);
        mod2 += K;
        l += K * 2;
        for (long long i = l; i <= r; i++)
            mod2 += (sum + i) % 2;
        return (ss - mod2) / 2;
    }
    long long cal(long long x, long long X)
    {
        long long res = 0;
        long long R = max({x, (X + 1) / 2, X + X - sum});
        if (x + x > (sum + x) / 2)
            res += S(x, R - 1);
        else
        {
            long long p = sum / 3;
            while (p + p < (sum + p) / 2)
                p++;
            while (p + p - 2 >= (sum + p - 1) / 2)
                p--;
            p = min(p, R);
            res += S(p, R - 1);
            if (p > x)
                res += (x + x + p - 1 + p - 1) * (p - x) / 2;
        }
        if (R <= X)
            res += X * (X - R + 1);
        long long len = X - x;
        return res + len * (len + 1) / 2 - (x + X) * (X - x + 1) / 2;
    }
    set<pair<long long, long long>> t;

public:
    void init(long long sum)
    {
        this->sum = sum;
    }
    void add(long long l, long long r)
    {
        auto it = t.lower_bound(make_pair(r, r));
        if (it != t.end() && it->first == r)
        {
            r = it->second;
            ans -= cal(it->first, it->second);
            t.erase(it);
        }
        it = t.lower_bound(make_pair(r, r));
        if (it != t.begin())
        {
            it = prev(it);
            if (it->second == l)
            {
                l = it->first;
                ans -= cal(it->first, it->second);
                t.erase(it);
            }
        }
        t.insert(make_pair(l, r));
        ans += cal(l, r);
    }
    void del(long long l, long long r)
    {
        auto it = prev(t.upper_bound({l, inf}));
        auto old = *it;
        ans -= cal(it->first, it->second);
        t.erase(it);
        if (old.first < l)
            add(old.first, l);
        if (old.second > r)
            add(r, old.second);
    }
};
int main()
{
    map<long long, Chtholly> t;
    int q, op;
    long long x1, x2, y1, y2;
    scanf("%d", &q);
    while(q--)
    {
        scanf("%d%lld%lld%lld%lld", &op, &x1, &y1, &x2, &y2);
        if (x1 > x2)
        {
            swap(x1, x2);
            swap(y1, y2);
        }
        long long sum = x1 + y1;
        if(t.count(sum) == 0)
            t[sum].init(sum);
        if (op == 1)
            t[sum].add(x1, x2);
        else
            t[sum].del(x1, x2);
        printf("%lld\n", ans);
    }
    return 0;
}

K NIO’s Sword

题意：初始 $x=0$，给定 $n$，每次执行操作 $x\leftarrow 10x+A$，$A\in [0,9]$，问使 $x\mathrm{mod}n$ 从 $1$ 依次变化到 $n$ 需要最少执行几次操作。$n\le 1\times 10^6$。

解法：从 $i$ 到 $i+1$ 有 $10^{k}i+y\equiv i+1(\mathrm{mod}n)$，其中 $y<10^k$，$k$ 为操作次数。因而 $y\equiv i(1-10^k)+1(\mathrm{mod}n)$。因而枚举 $k$ 即可。注意 $n=1$ 时答案为 $0$。

#include <bits/stdc++.h>
using namespace std;
long long th[20];
int main()
{
    th[0] = 1;
    for (int i = 1; i < 20;i++)
        th[i] = th[i - 1] * 10;
    int n;
    scanf("%d", &n);
    long long ans = 0;
    for (int i = 0; i < n;i++)
        for (int j = 0;;j++)
        {
            long long x = (1 - (th[j] - 1) * i % n + n) % n;
            if (x < th[j])
            {
                ans += j;
                break;
            }
        }
    printf("%lld", ans);
    return 0;
}

L Black Hole

题意：给定初始正 $n$ 面体和棱长，每次将其面心相连构成新正多面体，进行 $k$ 次，问最终是几面体、棱长多少。$n\le 200$，$k\le 20$，$a\le 1000$。

解法：只有五种正多面体：正四、六、八、十二、二十面体。这种变化规律下，四面体还是四面体，正六、八面体互换，正十二、二十面体互换。这是因为正六面体有 $8$ 个顶点，正八面体有 $6$ 个顶点，正十二面体有 $20$ 个顶点，正二十面体有 $12$ 个顶点。

正四面体内缩之后边长变为 $\frac{a}{3}$，正六面体内缩后边长变为 $\frac{a}{\sqrt{2}}$，正八面体内缩后边长变为 $\frac{\sqrt{2}a}{3}$。

对于正十二面体，每个面为正五边形。考虑面心到棱的距离为 $h=\frac{a}{2}\tan 54^{\circ }$，两个面的二面角为 $\theta =2\arctan (\varphi +1)=2\arcsin \sqrt{\frac{2}{5-\sqrt{5}}}$，其中 $\varphi =\frac{\sqrt{5}-1}{2}$，则面心距离为新的棱长，为 $2h\sin \frac{\theta }{2}=a\tan 54^{\circ }\sqrt{\frac{2}{5-\sqrt{5}}}$。

对于正二十面体，每个面为等边三角形。面心到棱长距离 $h=\frac{a}{2\sqrt{3}}$，两个面二面角为 $\theta =2\arctan (\varphi +2)=2\arcsin \frac{1+\sqrt{5}}{2\sqrt{3}}$，因而面心距 $2h\sin \frac{\theta }{2}=\frac{a(1+\sqrt{5})}{6}$。

#include <bits/stdc++.h>

using namespace std;
const int N = 205;
using db = double;
const db phi = (sqrt(5) - 1) / 2, pi = acos(-1);
int n, k, T[N];
db calc(db a, int t) {
    switch (t) {
    case 4: return a / 3;
    case 6: return a / sqrt(2);
    case 8: return a * sqrt(2) / 3;
    case 12: return a * tan(54 * pi / 180) * sin(atan(phi + 1));
    case 20: return a / sqrt(3) * sin(atan(phi + 2));
    }
    return -1;
}
void Solve() {
    db a;
    scanf("%d%lf%d", &n, &a, &k);
    if (!T[n]) return puts("impossible"), void();
    while (k--) a = calc(a, n), n = T[n];
    printf("possible %d %.12lf\n", n, a);
}
int main() {
    int t = 1;
    T[4] = 4, T[6] = 8, T[8] = 6, T[12] = 20, T[20] = 12;
    scanf("%d", &t);
    while (t--) Solve();
    return 0;
}

M Monotone Chain

题意：给定平面 $n$ 个点 $(x_i,y_i)$，找到两个向量 $\text{a},\text{b}$ 满足 $\forall 1\le i\le j\le n$，$({\text{OA}}_i-\text{a})\cdot \text{b}\le ({\text{OA}}_j-\text{a})\cdot \text{b}$。$n\le 1\times 10^5$，点范围 $|x_i|,|y_i|\le 1\times 10^5$。

解法：将原式化为 ${\text{OA}}_i\cdot \text{b}\le {\text{OA}}_j\cdot \text{b}$，即是满足 ${\text{OA}}_i\cdot \text{b}$ 单调递增。进一步的化简可以得到 ${\text{A}}_i{\text{A}}_j\cdot \text{b}\le 0$。那么问题转化为每个相邻的 $A_i{A}_{i+1}$ 确定了一个过原点的半个平面，问这些平面有无交点。这里可以无脑使用半平面交，但是更好的做法是使用双指针。首先对所有的不重合的 $A_i{A}_{i+1}$ 的射线方向进行极角排序，然后统计覆盖的射线数目，符合条件即输出当前边界的方向向量。全程可以不使用浮点数，复杂度 $\mathcal{O}(n\log n+n)$。

#include <bits/stdc++.h>
using namespace std;
using _T = long long; // 全局数据类型，可修改为 long long 等

constexpr _T eps = 0;
constexpr long double PI=3.1415926535897932384l;
 
// 点与向量
template<typename T> struct point
{
    T x, y;
 
    bool operator==(const point &a) const { return (abs(x - a.x) <= eps && abs(y - a.y) <= eps); }
    bool operator<(const point &a) const
    {
        if (abs(x - a.x) <= eps)
            return y < a.y - eps;
        return x < a.x - eps;
    }
    bool operator>(const point &a) const { return !(*this < a || *this == a); }
    point operator+(const point &a) const { return {x + a.x, y + a.y}; }
    point operator-(const point &a) const { return {x - a.x, y - a.y}; }
    point operator-() const { return {-x, -y}; }
    point operator*(const T k) const { return {k * x, k * y}; }
    point operator/(const T k) const { return {x / k, y / k}; }
    T operator*(const point &a) const { return x * a.x + y * a.y; } // 点积
    T operator^(const point &a) const { return x * a.y - y * a.x; } // 叉积，注意优先级
    int toleft(const point &a) const
    {
        const auto t = (*this) ^ a;
        return (t > eps) - (t < -eps);
    }                                      // to-left 测试
    T len2() const { return (*this) * (*this); }                  // 向量长度的平方
    T dis2(const point &a) const { return (a - (*this)).len2(); } // 两点距离的平方
 
    // 涉及浮点数
    long double len() const { return sqrtl(len2()); }                                                                      // 向量长度
    long double dis(const point &a) const { return sqrtl(dis2(a)); }                                                       // 两点距离
    long double ang(const point &a) const { return acosl(max(-1.0, min(1.0, ((*this) * a) / (len() * a.len())))); }        // 向量夹角
    point rot(const long double rad) const { return {x * cos(rad) - y * sin(rad), x * sin(rad) + y * cos(rad)}; }          // 逆时针旋转（给定角度）
    point rot(const long double cosr, const long double sinr) const { return {x * cosr - y * sinr, x * sinr + y * cosr}; } // 逆时针旋转（给定角度的正弦与余弦）
};
 
using Point=point<_T>;
 
// 极角排序
struct argcmp
{
    bool operator()(const Point &a,const Point &b) const
    {
        const auto quad=[](const Point &a)
        {
            if (a.y<-eps) return 1;
            if (a.y>eps) return 4;
            if (a.x<-eps) return 5;
            if (a.x>eps) return 3;
            return 2;
        };
        const int qa = quad(a), qb = quad(b);
        if (qa != qb)
            return qa < qb;
        const auto t = a ^ b;
        // if (abs(t)<=eps) return a*a<b*b-eps; // 不同长度的向量需要分开
        return t > eps;
    }
};

int main()
{
    int n;
    scanf("%d", &n);
    vector<Point> pt(n);
    for (int i = 0; i < n;i++)
        scanf("%lld%lld", &pt[i].x, &pt[i].y);
    vector<Point> que;
    for (int i = 1; i < n;i++)
    {
        long long x = pt[i].x - pt[i - 1].x, y = pt[i].y - pt[i - 1].y;
        if (x || y)
        {
            Point st = (Point){x, y};
            que.emplace_back(st);
        }
    }
    n = que.size();
    if (!n)
    {
        printf("YES\n0 0 1 0");
        return 0;
    }
    sort(que.begin(), que.end(), argcmp());
    for (int i = 0; i < n;i++)
        que.push_back(que[i]);
    for (int l = 0, r = 0; l < n;l++)
    {
        while (r < l + n && (que[l] ^ que[r]) >= 0)
            r++;
        if(r == l + n)
        {
            printf("YES\n0 0 %lld %lld\n", -que[l].y, que[l].x);
            return 0;
        }
    }
    printf("NO");
    return 0;
}

N Particle Arts

题意：给定序列 { a n } \{a_n\} {an​}，可以执行无穷多次操作：选定两个数字 $a_i,a_j$，然后 $a_i\leftarrow a_i\&a_j$，$a_j\leftarrow a_i|a_j$，问最大方差。$n\le 1\times 10^5$，$a_i\le 2^{15}$。

解法：$a_i+a_j=(a_i\&a_j)+(a_i|a_j)$，因而 $\sigma$ 不变。当 $\mu$ 最大时一定是数字差距最大的。因而对于每一位分开考虑，若第 $i$ 位上有 $k$ 个 $1$ 则把最大的 $k$ 个数字加上 $2^i$，这样得到新序列 { b n } \{b_n\} {bn​}。然后根据公式计算 $\mu =\frac{1}{n^3}\sum _{i=1}^n{\left(n{b}_i-\sum _{j=1}^n{b}_j\right)}^2$ 即可。注意计算过程中会爆 long long，需要使用 int_128。

#include <bits/stdc++.h>
using namespace std;
void print(__int128_t x)
{
    string s;
    while(x)
    {
        s += x % 10 + 48;
        x /= 10;
    }
    if(s.empty())
        s += "0";
    reverse(s.begin(), s.end());
    cout << s;
}
int main()
{
    int n;
    scanf("%d", &n);
    vector<long long> a(n);
    long long sum = 0;
    for (int i = 0; i < n;i++)
    {
        scanf("%lld", &a[i]);
        sum += a[i];
    }
    vector<int> times(21, 0);
    for (auto i : a)
        for (int j = 0; j <= 20;j++)
            if (i & (1 << j))
                times[j]++;
    for (auto &i : a)
        i = 0;
    for (int i = 0; i <= 20;i++)
        for (int j = 0; j < times[i];j++)
            a[j] |= 1ll << i;
    __int128_t ans = 0;
    for (int i = 0; i < n;i++)
    {
        __int128_t now = a[i] * n - sum;
        ans += now * now;
    }
    __int128_t x = ans, y = (__int128_t)n * n * n;
    __int128_t g = __gcd(x, y);
    print(x / g);
    printf("/");
    print(y / g);
    return 0;
}