2022 年杭电多校第三场补题记录

A Equipment Upgrade

题意：有一个人从 $0$ 要走到 $n$，在 $x=i,i\in [0,n-1]$ 处可以花费 $c_i$ 的代价，有 $p_i$ 的概率走到 $x=i+1$；然后给定长度为 $n-1$ 的权值数组 { w i } \{w_i\} {wi​} 表示往下掉 $i$ 步的概率，即在 $x=i$ 处有 $\frac{w_j}{{\sum }_{k=1}^i{w}_k}$ 的概率落到 $i-j$ 处。问期望走到 $n$ 所花费的代价。$n\le 1\times 10^5$。

解法：设 $F_i$ 表示从 $0$ 走到 $i$ 的期望代价。考虑 $x=i$ 处转移到 $F_{i+1}$ 的情况：

1. 以 $p_i$ 的概率走到 $i+1$。
2. 以 $1-p_i$ 的概率不断往下掉再爬回来。

设 $W$ 为已经确认掉下去了，再爬回来的期望代价，则有：
$$\begin{array}{rl}{F}_{i+1}=& \sum _{j=0}^{+\infty }{p}_i(1-p_i{)}^j((1+j)c_i+jW)\\ =& \frac{c_i}{p_i}+p_{i}W\sum _{j=0}^{+\infty }(1-p_i{)}^{j}j\\ =& \frac{c_i}{p_i}+\frac{1-p_i}{p_i}W\end{array}$$
考虑 $W$ 的构成。对于掉到 $i-j$，其概率为 $\frac{w_j}{{\sum }_{k=1}^i{w}_k}$，再从 $i-j$ 回到 $i$ 的期望代价为 $f_i-f_j$。因而 $W=\frac{1}{{\sum }_{k=1}^i{w}_k}\sum _{j=1}^i{w}_j(F_i-F_{i-j-1})=F_i-\frac{1}{{\sum }_{k=1}^i{w}_k}\sum _{j=1}^i{w}_j{F}_{i-j-1}$。

因而最终化简的式子为 $F_{i+1}=\frac{c_i+(1-p_i)F_i}{p_i}-\frac{1-p_i}{p_i{\sum }_{k=1}^i{w}_k}\sum _{j=1}^i{w}_j{F}_{i-j-1}$。这是一个典型的半在线卷积形式，因而使用分治 NTT 可以 $\mathcal{O}(n{\log }^{2}n)$ 通过本题。

void fenzhi(int l,int r){
	if(l==r){
		if(l){
			f[l]=mod(1ll*mod(1-P[l-1]+p)*pw[l-1]%p*f[l]%p+mod(f[l-1]+c[l-1])),
			f[l]=1ll*f[l]*ksm(P[l-1],p-2)%p;	
		}
		return;
	}
	int mid=l+r>>1;
	fenzhi(l,mid);
	mul(f+l,w,a,mid-l+1,r-l+1);
	for(int i=mid+1;i<=r;++i) f[i]=mod(f[i]-a[i-l-1]+p);
	fenzhi(mid+1,r);
}
void solve(){
	n=in();int i100=ksm(100,p-2);
	memset(f,0,8*n);
	for(int i=0;i<n;++i) P[i]=1ll*in()*i100%p,c[i]=in();
	for(int i=1;i<n;++i) w[i]=in(),pw[i]=mod(pw[i-1]+w[i]);
	for(int i=1;i<n;++i) pw[i]=ksm(pw[i],p-2);
	fenzhi(0,n);
	printf("%d\n",f[n]);
}
int main()
{
	int T=in();
	while(T--) solve();
	return 0;
}

B Boss Rush

题意：有 $n$ 个技能，每个技能使用完成之后有 $t_i$ 秒的冷却时间，以及一个长度为 $l_i$ 的序列 { d i } \{d_i\} {di​} 表示这个技能接下来的 $l_i$ 秒中，每一秒这个技能对敌人的伤害。给定敌人的血量 $H$，问在每个技能至多使用一次的情况下，至少使用多长时间才能将敌人击杀，或者报告不能击杀。$n\le 18$，$\sum l_i\le 3\times 10^5$，$H\le 1\times 10^{18}$。

解法：显然伤害对时间是单调递增的，且为了尽快击杀，技能是连续释放的。同时由于 $n$ 非常小，考虑二分答案套状态压缩。二分击杀时间 $T$，设 $f_S$ 表示技能使用情况为 $S$，在 $t$ 时刻前所能打出的最大伤害。记 $t_S$ 为使用 $S$ 这些技能所用时间，则枚举未使用的技能 $i$，其开始使用时间为 $t_s$，$i$ 技能所能打出的伤害秒数为 $j=\min (T-t_S,l_i)$，则伤害利用 { d i } \{d_i\} {di​} 的前缀和可以 $\mathcal{O}(1)$ 的计算。因而 $f_{S\cup i}\leftarrow \underset{i\notin S}{\max }\left\{f_S+\sum _{k=0}^j{d}_{i,k}\right\}$。总时间复杂度 $\mathcal{O}(n{2}^n\log \sum l_i)$。

此题使用二分的核心在于：如果时间不知道，那么每个技能所能打出伤害的时间是不可知的，因而非常不好转移。本题卡常。

#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
const int N = 1 << 18, M = 100000;
int oldtime[N];
long long f[N], t[20];
long long d[20][M + 5], h;
int len[20], n;
bool check(int val)
{
    for (int i = 0; i < 1 << n;i++)
        f[i] = 0;
    for (int i = 1; i < 1 << n; i++)
        for (int j = 0; j < n; j++)
            if (i & (1 << j))
            {
                int old = i ^ (1 << j);
                if (oldtime[old] > val)
                    continue;
                int hitlen = min(len[j] - 1, val - oldtime[old]);
                f[i] = max(f[i], f[old] + d[j][hitlen]);
            }
    for (int i = 0; i < 1 << n; i++)
        if (f[i] >= h)
            return true;
    return false;
}
int main()
{
    int test;
    scanf("%d", &test);
    while(test--)
    {
        scanf("%d%lld", &n, &h);
        for (int i = 0, x; i < n;i++)
        {
            scanf("%d%d", &t[i], &len[i]);
            for (int j = 0; j < len[i];j++)
            {
                scanf("%lld", &d[i][j]);
                if(j)
                    d[i][j] += d[i][j - 1];
            }
        }
        long long all = 0;
        for (int i = 0; i < n;i++)
            all += d[i][len[i] - 1];
        if(all < h)
        {
            printf("-1\n");
            continue;
        }
        for (int i = 0; i < 1 << n;i++)
        {
            oldtime[i] = 0;
            for (int j = 0; j < n;j++)
                if (i & (1 << j))
                    oldtime[i] += t[j];
        }
        int left = 0, right = 5e6, ans = -1;
        while (left <= right)
        {
            int mid = (left + right) >> 1;
            if (check(mid))
            {
                ans = mid;
                right = mid - 1;
            }
            else
                left = mid + 1;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

C Cyber Language

题意：对于一串用空格分隔的若干字符串，将其首字母大写。

解法：直接模拟即可。

E Spanning Tree Game

题意：给定一个 $n$ 个点 $m$ 条边的联通无向图，和两个长度为 $m$ 的序列 { a i } \{a_i\} {ai​} 和 { b i } \{b_i\} {bi​}，求出：对于 $k\in [0,m]$，Alice 从 $m$ 条边中选取 $k$ 条边 { e 1 , e 2 , ⋯   , e k } \{e_1,e_2,\cdots,e_k\} {e1​,e2​,⋯,ek​}，它们的权值为 { a e 1 , a e 2 , ⋯   , a e k } \{a_{e_1},a_{e_2},\cdots,a_{e_k}\} {ae1​​,ae2​​,⋯,aek​​}，对于剩下的边 { e k + 1 , e k + 2 , ⋯   , e m } \{e_{k+1},e_{k+2},\cdots,e_m\} {ek+1​,ek+2​,⋯,em​}，其权值为 { b e k + 1 , b e k + 2 , ⋯   , b e m } \{b_{e_{k+1}},b_{e_{k+2}},\cdots,b_{e_m}\} {bek+1​​,bek+2​​,⋯,bem​​}，Bob 对于这张带权图求最小生成树，Alice 希望生成树权值尽可能大，问这颗树的最大权值。$n\le 9$，$m\le 30$。

解法：考虑将每条边拆成两个：$(u_i,v_i,a_i)$ 和 $(u_i,v_i,b_i)$，若 $a_i\ge b_i$ 则存入 $(u_i,v_i,b_i,-1),(u_i,v_i,a_i,0)$；若 $a_i<b_i$，则存入 $(u_i,v_i,a_i,1),(u_i,v_i,b_i,0)$。最后一个参数的含义为，选择这条边会让选择的 $a$ 集合个数变化量。

首先依照 Kruskal 对所有边排序，依照权值为第一关键字，集合变化量为第二关键字，$0$ 边后置。依次对所有的边进行遍历，考虑枚举到的边有以下三种情况：

1. $(u,v,w,1)$，则此边是不一定需要的（后面还有同样的边）。若 $u,v$ 不连通则权值增加 $w$，且 $a$ 数组选的个数增加 $1$。
2. $(u,v,w,-1)$，则此边是不一定需要的（后面还有同样的边）。若 $u,v$ 不连通则权值增加 $w$，且 $a$ 数组选的个数减少 $1$。
3. $(u,v,w,0)$。则 $(u,v)$ 边已经被考虑过了。若之前的那条边没选，且 $(u,v)$ 不连通，则此边必选；若已经选了，增加这条边显然树权值不会减小。因而只需要考虑未连通的情况下权值增加 $w$，且 $a$ 数组选的个数不变。

考虑所有的图连通情况，即是将 $n$ 个数分到若干个集合，集合非空。这一方案数为 $\sum _{i=1}^n\left\{\genfrac{}{}{0ex}{}{n}{i}\right\}={\varpi }_n$，注意到 ${\varpi }_9=21147$，因而设置 dp 数组：$f_{i,j,k}$ 表示对于前 $i$ 条边，连通状态为 $j$，且 $a$ 集合选取了 $k$ 条边的最大权值，每次的 dp 转移都是 $\mathcal{O}(1)$，使用滚动数组优化空间，总的时间复杂度为 $\mathcal{O}(m^2{\varpi }_n)$。

F Dusk Moon

题意：平面上有 $n$ 个点 $(x_i,y_i)$，有以下 $q$ 次、两种操作：

1. 将第 $j$ 个点移动到 $(x^{\prime },y^{\prime })$；
2. 查询区间 $[l,r]$ 构成的点集合 $\{(x_l,y_l),(x_{l+1},y_{l+1}),\cdots ,(x_r,y_r)\}$ 的最小圆覆盖。

$n,q\le 1\times 10^5$，点随机给出。

解法：对于随机给出的 $n$ 个点，其期望的凸包点数为 $O(\log n)$ 个的。因而使用线段树暴力维护区间 $[l,r]$ 的凸包点集，对于子区间的合并可以每次暴力使用 Andrew 算法重新计算，然后使用随机情况下 $O(n)$ 的最小圆覆盖算法，总的时间复杂度为 $\mathcal{O}(q{\log }^{2}n\log \log n)$。或者可以归并排序的写法，减去 Andrew 算法的排序，减少这一 $\log \log n$。本题卡常。

I Package Delivery

题意：有 $n$ 个包裹，每个包裹取件时间为 $[l_i,r_i]$。可以在任意一天取任意多次包裹，每次至多取 $k$ 个包裹，问最少取多少次包裹。$1\le k\le n\le 1\times 10^6$。

解法：考虑贪心，显然需要在最晚的一天取尽可能多的包裹。

首先对于所有的区间，按左端点 $l$ 排序。同时维护一个堆，表示现在可以取的包裹，堆内按 $r$ 排序。按右端点先后枚举区间，每次取出还未取走的最小的 $r$ 的那个包裹，将还未塞入堆中的所有满足 $l_i\le r$ 的包裹全部塞进堆中，在堆内找到 $r$ 最小的 $k$ 个包裹（或取空）取走，并且必须保证当前这个枚举的包裹被取走。

总时间复杂度为 $\mathcal{O}(n\log n)$。

#include <bits/stdc++.h>
using namespace std;
struct node
{
    int l, r;
    int id;
    bool operator<(const node &b)const
    {
        return r > b.r;
    }
};
int main()
{
    int t, n, k;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &k);
        vector<node> que(n);
        for (int i = 0; i < n;i++)
        {
            scanf("%d%d", &que[i].l, &que[i].r);
            que[i].id = i;
        }
        vector<int> vis(n, 0);
        vector<node> quer = que;
        auto cmpl = [&](node a, node b)
        {
            return a.l < b.l;
        };
        auto cmpr = [&](node a, node b)
        {
            return a.r < b.r;
        };
        sort(que.begin(), que.end(), cmpr);
        sort(quer.begin(), quer.end(), cmpl);
        priority_queue<node> q;
        int ans = 0, place = 0;
        for (int i = 0; i < n;i++)
        {
            if(vis[que[i].id])
                continue;
            while (place < n && quer[place].l <= que[i].r)
                q.push(quer[place++]);
            int cnt = 0;
            while(!q.empty() && cnt + (!vis[q.top().id]) <= k)
            {
                cnt += (!vis[q.top().id]);
                vis[q.top().id] = 1;
                q.pop();
            }
            ans++;
            if(!vis[que[i].id])
                i--;
        }
        if(!q.empty())
            ans += (q.size() + k - 1) / k;
        printf("%d\n", ans);
    }
    return 0;
}

K Taxi

题意：给定平面上 $n$ 个点 $(x_i,y_i)$ 和权值 $w_i$，任意一个点 $(x,y)$ 到它的代价为 $\min (w_i,|x-x_i|+|y-y_i|)$。$q$ 次询问，每次给出一个点 $(x,y)$，问到这 $n$ 个点的最大权值。$n,q\le 5\times 10^5$。

解法：单纯考虑 $|x-x_i|+|y-y_i|$，拆开绝对值可以分成 $4$ 个情况——$x+y+\max (-x_i-y_i)$，$x-y+\max (-x_i+y_i)$，$-x+y+\max (x_i-y_i)$，$-x-y+\max (x_i+y_i)$，依次分开维护 $\max (-x_i-y_i),\max (x_i-y_i),\max (-x_i,y_i),\max (x_i+y_i)$ 即可。

考虑引入 $w$——按 $w$ 排序从小到大排序，再加入 $|x-x_i|+|y-y_i|$ 的限制，即是在 $w$ 这一参数单调递增的情况下维护这四个权值的后缀最大值。预处理后可以做到 $\mathcal{O}(1)$ 查询曼哈顿距离最大值。

考虑单调性：后缀最大值单调递减，$w$ 单调递增，对这两个取 $\min$ 后必然有一单峰。因而使用二分——对于一个分界点 $k$，首先查询后缀 $k$ 的曼哈顿距离最大值 $d_k$，和权值最小值 $w_k$，若 $d_k\le w_k$ 则表示 $w$ 不对会曼哈顿距离的最大值造成影响，分界点可以向前；否则 $w_k$ 就会影响答案，需要继续向后移动 $k$。利用这一隐藏的单调性可以做到单次询问 $\mathcal{O}(\log n)$。

#include <bits/stdc++.h>
using namespace std;
struct node
{
    long long x, y;
    long long w;
    bool operator<(const node &b)const
    {
        return w < b.w;
    }
};
int main()
{
    int t, n, q;
    long long x, y;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &q);
        vector<node> que(n);
        for (int i = 0; i < n;i++)
            scanf("%lld%lld%lld", &que[i].x, &que[i].y, &que[i].w);
        sort(que.begin(), que.end());
        vector<long long> suf1(n), suf2(n), suf3(n), suf4(n);
        for (int i = n - 1; i >= 0;i--)
        {
            suf1[i] = que[i].x + que[i].y;
            suf2[i] = que[i].x - que[i].y;
            suf3[i] = -que[i].x + que[i].y;
            suf4[i] = -que[i].x - que[i].y;
            if (i + 1 < n)
            {
                suf1[i] = max(suf1[i], suf1[i + 1]);
                suf2[i] = max(suf2[i], suf2[i + 1]);
                suf3[i] = max(suf3[i], suf3[i + 1]);
                suf4[i] = max(suf4[i], suf4[i + 1]);
            }
        }
        auto cal = [&](long long x, long long y, int id)
        {
            return max({suf1[id] - x - y, suf2[id] - x + y, suf3[id] + x - y, suf4[id] + x + y});
        };
        while(q--)
        {
            scanf("%lld%lld", &x, &y);
            int left = 0, right = n - 1;
            long long ans = 0;
            while (left <= right)
            {
                int mid = (left + right) >> 1;
                ans = max(ans, min(cal(x, y, mid), que[mid].w));
                if (cal(x, y, mid) <= que[mid].w)
                    right = mid - 1;
                else
                    left = mid + 1;
            }
            printf("%lld\n", ans);
        }
    }
    return 0;
}

L Two Permutations

题意：给定两个长度为 $n$ 的排列 $A,B$，进行归并，问能够归并成长度为 $2n$ 的序列 $C$，如果能输出方案数。$n\le 1\times 10^6$。

解法：考虑一个暴力 dp：$f_{i,j}$ 表示 $A$ 序列取出 $i$ 个，$B$ 序列取出 $j$ 个的方案数。则对于 $C$ 序列已经覆盖了 $i+j$ 个数。其转移为 $f_{i,j+1}\leftarrow f_{i,j}[C_{i+j+1}=B_{j+1}]$，$f_{i+1,j}\leftarrow f_{i,j}[C_{i+j+1}=A_{i+1}]$。但是这个暴力其实复杂度是 $\mathcal{O}(4n)$ 的——因为满足 $C_{i+j+1}=B_{j+1}$ 和 $C_{i+j+1}=A_{i+1}$ 的只有 $4n$ 次。因而总状态数也只有 $4n$，可以使用记忆化搜索通过。

#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int main()
{
    int t, n;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        unordered_map<long long, long long> f;
        vector<int> p(n + 1), q(n + 1), s(2 * n + 1);
        for (int i = 1; i <= n;i++)
            scanf("%d", &p[i]);
        for (int i = 1; i <= n;i++)
            scanf("%d", &q[i]);
        vector<int> times(n + 1, 0);
        for (int i = 1; i <= 2 * n;i++)
        {
            scanf("%d", &s[i]);
            times[s[i]]++;
        }
        bool flag = 0;
        for (int i = 1; i <= n;i++)
            if (times[i] != 2)
            {
                flag = 1;
                break;
            }
        if(flag)
        {
            printf("0\n");
            continue;
        }
        vector<int> memo(n + 1, -1);
        function<int(int, int, int)> dfs = [&](int x, int y, int z)
        {
            if (z == 2 * n + 1)
                return 1;
            if (x <= n && y <= n && p[x] == q[y])
            {
                if (p[x] == s[z])
                {
                    if(memo[p[x]] == -1)
                        return memo[p[x]] = (dfs(x + 1, y, z + 1) + dfs(x, y + 1, z + 1)) % mod;
                    else
                        return memo[p[x]];
                }
                else
                    return 0;
            }
            if (x <= n && p[x] == s[z])
                return dfs(x + 1, y, z + 1);
            if (y <= n && q[y] == s[z])
                return dfs(x, y + 1, z + 1);
            return 0;
        };
        printf("%d\n", dfs(1, 1, 1));
    }
    return 0;
}