2023.02.24 模拟赛小结

更好的阅读体验戳此进入

赛时思路

T1

给定序列 $A_n$$A_n$ 和模数 $p$$p$，求从 $[1,n]$$[1, n]$ 每个位置向左或右延申形成的子串的所有元素模意义下的和的最大值。

签到题，考虑维护模意义下的前缀和和后缀和，然后如对于 $i$$i$ 位置，假设其前缀和为 $su{m}_i$$sum_i$，那么显然如果为了让其向右延申之后的值更大那么最优是找到一个在 $i$$i$ 以后的前缀和满足等于 $p-1+su{m}_{i-1}$$p - 1 + sum_{i - 1}$，如果不存在则最优是找到小于其的任意数，如果不存在小于的那么直接找剩余的最大数即可。对于向前延伸的逆过来做一遍即可。最开始考虑的直接开个 basic_string 然后二分找，但是发现需要删除元素，然后就上了个权值线段树然后在上面乱搞，然而实际上直接用 set 就可以了。

Code

xxxxxxxxxx
133
1
#define _USE_MATH_DEFINES
2
#include <bits/stdc++.h>
3

4
#define PI M_PI
5
#define E M_E
6
#define npt nullptr
7
#define SON i->to
8
#define OPNEW void* operator new(size_t)
9
#define ROPNEW void* Edge::operator new(size_t){static Edge* P = ed; return P++;}
10
#define ROPNEW_NODE void* Node::operator new(size_t){static Node* P = nd; return P++;}
11

12
using namespace std;
13

14
mt19937 rnd(random_device{}());
15
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
16
bool rnddd(int x){return rndd(1, 100) <= x;}
17

18
typedef unsigned int uint;
19
typedef unsigned long long unll;
20
typedef long long ll;
21
typedef long double ld;
22

23

24

25
template < typename T = int >
26
inline T read(void);
27

28
int N, P;
29
int w[110000];
30
int sum[110000];
31
int rsum[110000];
32
int ans[110000];
33
int mx(-1), rmx(-1);
34
basic_string < int > vals;
35

36
class SegTree{
37
private:
38
    int tr[65536 << 2];
39
    #define LS (p << 1)
40
    #define RS (LS | 1)
41
    #define MID ((gl + gr) >> 1)
42
public:
43
    void Pushup(int p){
44
        tr[p] = tr[LS] + tr[RS];
45
    }
46
    void Modify(int val, int cnt = 1, int p = 1, int gl = 0, int gr = P - 1){
47
        // printf("In mdf val = %d, gl = %d, gr = %d\n", val, gl, gr);
48
        // for(int i = 1; i <= 50000000; ++i);
49
        if(gl == gr)return tr[p] += cnt, void();
50
        if(val <= MID)Modify(val, cnt, LS, gl, MID);
51
        else Modify(val, cnt, RS, MID + 1, gr);
52
        Pushup(p);
53
    }
54
    int QueryRight(int p, int gl, int gr){
55
        if(gl == gr)return tr[p] ? gl = gr : -1;
56
        if(tr[RS])return QueryRight(RS, MID + 1, gr);
57
        return QueryRight(LS, gl, MID);
58
    }
59
    int QueryLeftMost(int val, int p = 1, int gl = 0, int gr = P - 1){
60
        if(gl == gr)return gl <= val && tr[p] ? gl : -1;
61
        int mx(-1);
62
        if(MID <= val)mx = max(mx, QueryRight(LS, gl, MID));
63
        else return QueryLeftMost(val, LS, gl, MID);
64
        return max(mx, QueryLeftMost(val, RS, MID + 1, gr));
65
    }
66
    int QueryLastRight(int p = 1, int gl = 0, int gr = P - 1){
67
        if(gl == gr)return tr[p] ? gl = gr : -1;
68
        if(tr[RS])return QueryLastRight(RS, MID + 1, gr);
69
        return QueryLastRight(LS, gl, MID);
70
    }
71
}st1, st2;
72

73
int main(){
74
    freopen("clean.in", "r", stdin);
75
    freopen("clean.out", "w", stdout);
76
    N = read(), P = read();
77
    for(int i = 1; i <= N; ++i)
78
        w[i] = read(),
79
        sum[i] = (sum[i - 1] + w[i]) % P,
80
        st1.Modify(sum[i]),
81
        mx = max(mx, sum[i]);
82
    for(int i = N; i >= 1; --i)
83
        rsum[i] = (rsum[i + 1] + w[i]) % P,
84
        st2.Modify(rsum[i]),
85
        rmx = max(rmx, rsum[i]);
86
    // sort(sum + 1, sum + N + 1);
87
    // for(int i = 1; i <= N; ++i)vals += sum[i];
88
    // sort(vals.begin(), vals.end());
89
    for(int i = 1, j = N; i <= N; ++i, --j){
90
        
91
        // auto it = lower_bound(vals.begin(), vals.end(), val);
92
        // int ans(-1);
93
        // if(it != vals.end())ans = max(ans, (*it - sum[i] + P) % P);
94
        // if(it != vals.end() && next(it) != vals.end())ans = max(ans, (*next(it) - sum[i] + P) % P);
95
        // if(it != vals.begin())ans = max(ans, (*prev(it) - sum[i] + P) % P);
96
        int val = (P - 1 + sum[i - 1]) % P;
97
        int ret = st1.QueryLeftMost(val);
98
        // printf("QLM1 i = %d, val = %d, ret = %d, sum is %d\n", i, val, ret, sum[i - 1]);
99
        if(!~ret)ret = st1.QueryLastRight();
100
        ans[i] = max(ans[i], (ret - sum[i - 1] + P) % P);
101
        st1.Modify(sum[i], -1);
102
        val = (P - 1 + rsum[j + 1]) % P;
103
        ret = st2.QueryLeftMost(val);
104
        // printf("QLM2 j = %d, val = %d, ret = %d, rsum is %d\n", j, val, ret, rsum[j + 1]);
105
        if(!~ret)ret = st2.QueryLastRight();
106
        ans[j] = max(ans[j], (ret - rsum[j + 1] + P) % P);
107
        st2.Modify(rsum[j], -1);
108
    }
109
    for(int i = 1; i <= N; ++i)printf("%d%c", ans[i], i == N ? '\n' : ' ');
110
    fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
111
    return 0;
112
}
113

114
/*
115
4 16
116
2 7 9 11
117
*/
118

119
template < typename T >
120
inline T read(void){
121
    T ret(0);
122
    int flag(1);
123
    char c = getchar();
124
    while(c != '-' && !isdigit(c))c = getchar();
125
    if(c == '-')flag = -1, c = getchar();
126
    while(isdigit(c)){
127
        ret *= 10;
128
        ret += int(c - '0');
129
        c = getchar();
130
    }
131
    ret *= flag;
132
    return ret;
133
}

T2

存在 $n$$n$ 个元素每个元素存在 $I_i,S_i$$I_i, S_i$，保证 $I_i\le S_i$$I_i \le S_i$，你需要排列其以使得对于每相邻两个都有 $S_i>I_{i+1}$$S_i \gt I_{i + 1}$。

奇怪题，也没什么阳间部分分，全贪心。。不会。。

T3

题面很长不想简化了。。。。总之题意理解错了暴力寄了。

T4

存在 $n=2^k$$n = 2^k$ 个人，每个人有 $h_i$$h_i$ 的权值，保证给定的权值为 $[1,n]$$[1, n]$ 的排列，一共执行 $k$$k$ 轮竞赛每次奇数编号的与比其编号多 $1$$1$ 的比赛，权值更高的留下。在线地多次独立询问，给定 $x,y$$x, y$ 求对于权值为 $x$$x$ 的人若可以在赛前交换最多 $y$$y$ 次人的位置最多可以使得子集赢得多少场比赛。

拼了个 $k=1,k=2$$k = 1, k = 2$ 的部分分，总之就是还是不会，寄。

正解

T2

个人认为这道题的关键是需要考虑到之后当前的 $S_i$$S_i$ 会对后面造成影响，$I_i$$I_i$ 会因为合法的插入已经满足对 $i-1$$i - 1$ 的限制而失效。

看题解才发现 nt 的我忽略了 $I_i\le S_i$$I_i \le S_i$，对于部分分即不存在 $I_i=S_i$$I_i = S_i$ 可以考虑直接贪心，以 $S_i$$S_i$ 为第一关键字 $I_i$$I_i$ 为第二关键字排序，这样不难发现存在 $S_i\ge S_{i+1}>I_{i+1}$$S_i \ge S_{i + 1} \gt I_{i + 1}$，显然满足题意。

考虑正解，对于 $I_i=S_i$$I_i = S_i$ 的花不能无脑地放在一起，因为可能可以通过在其中插一些花使得其变为合法，于是考虑贪心。

对于 $I$$I$ 相同的优先取 $S$$S$ 更大的，对于 $I$$I$ 不同的优先取 $I$$I$ 更大的，用 set 维护即可。

T3

大概就是首先把问题简化一下，发现撤销没有额外代价，于是考虑可以回收的时候回收所有能回收的点的贡献一定是最优的。

于是发现问题转换为仅有两种行进方式，即从 $i$$i$ 到 $j$$j$ 走一条均同色的道路，以及从 $i$$i$ 到 $j$$j$ 走同色道路后再走到异色 $k$$k$ 并回收 $i$$i$ 到 $j$$j$，代价是 $k$$k$ 的代价。

于是问题再次转化，发现从 $i$$i$ 出发到 $k$$k$ 与从 $k$$k$ 出发的代价相同，于是直接转化为从一个与 $t$$t$ 颜色相同的点到 $t$$t$ 的代价。于是用 Floyd 快速求出从 $i$$i$ 到 $j$$j$ 的只走同色路的最短路，然后处理一下再跑一遍求出来任意两点之间只按照后者形式走的代价，然后对于任意的 $s,t$$s, t$ 枚举中转点然后求一下即可。

T4

感觉后几个部分分和离线的部分分还是可想的，在线正解有点智慧了，总之跳了。。

UPD

update-2023_02_24 初稿