【题解】NOIP2021模拟赛

已于 2023-09-07 21:10:37 修改
阅读量1.1k 收藏
点赞数
分类专栏： 题解 文章标签： 算法 动态规划 图论
于 2021-07-19 22:28:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqbzlydd/article/details/118914296
版权
本文探讨了动态规划在解决组合优化问题中的应用，如序列合并与分裂，以及最大异或路径问题。同时，介绍了利用线段树解决区间等差序列查询与修改操作的问题，并分析了在大规模序列中实现全为2的方案数的递推算法。这些信息技术领域的经典算法展示了数据结构与优化技巧的重要性。
摘要由CSDN通过智能技术生成

A.

状压 dp 。考虑到合并和分裂是互逆操作，所以只需要考虑合并操作。

trick: 将 b[i] 设置为 -b[i] ，题目转化为对一个序列，找到尽量多的和为 0 的集合。暴力转移是 O(3^(n+m)) ，我们考虑优化转移。

注意到 sum=0 时贡献加一，可以设计出如下转移方程 ：

dp[i]=max(dp[j]+dp[i-j])+(sum==0),j \in i

时间复杂度 O((n+m)2^(n+m))。 实际优化并不大。

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
inline int read()
{
	int X=0; bool flag=1; char ch=getchar();
	while(ch<'0'||ch>'9') {if(ch=='-') flag=0; ch=getchar();}
	while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
	if(flag) return X;
	return ~(X-1);
}
const int mx=25;
int T,n,m,a[mx],dp[1<<20];
int main() {
	freopen("operator.in","r",stdin);
	freopen("operator.out","w",stdout);
    scanf("%d",&T);
    while(T--) {
    	memset(dp,0,sizeof(dp));
        scanf("%d",&n);for(int i=0;i<n;i++) scanf("%d",&a[i]);
        scanf("%d",&m);for(int i=0;i<m;i++) scanf("%d",&a[n+i]),a[n+i]=-a[n+i];
        for(int i=1;i<(1<<n+m);i++) {
        	int tot=0;
        	for(int j=0;j<n+m;j++) {
        		if((i>>j)&1) ｛
				tot+=a[j];
			}
			dp[i]=max(dp[i],1);
			for(int j=(i-1)&i;j;j=(j-1)&i) {
				dp[i]=max(dp[i],dp[i-j]+dp[j]);
			}
		}
		printf("%d\n",n+m-dp[(1<<n+m)-1]*2);
    }
}

B.

题意：给定一个序列，有 m 次操作，每次选择数对 (a[i],a[j])，i!=j 且不重复，价值为 a[i]^a[j] ，求最大价值总和。 n<=5e4,m<=n^2 。

Solution:

比较棘手的一道题。

不难想到 Trie树 ，但是我 Trie 没学好。

那么这道题很像最大异或路径。想想我们是怎么做的：枚举 a[i] ，然后在 Trie 树上查找路径，时间复杂度 O(nlogn) ，前提是每次只跳一边。

方便起见，我们令 m*2 ，答案除以 2 即可。二分第 m*2 大值 mid ，计算出异或值 >=mid 的数对个数，这部分时间复杂度 O(nlog^2n) 。

最后来计算答案。对于 >=m*2 的部分，每一个减去 mid 即可。这里维护以 i 为子树，第 j 位为 1 的数的个数，时间复杂度 O(nlog^2n) 。

综上，我们用 Trie 树在 O(nlog^2n) 时间内过了此题。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mx = 5e6 + 5;
const int mod = 1e9 + 7;
inline ll read() {
    ll X = 0;
    bool flag = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            flag = 0;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        X = (X << 1) + (X << 3) + ch - '0';
        ch = getchar();
    }
    if (flag)
        return X;
    return ~(X - 1);
}
int n, tot = 1, a[mx], trie[mx][2];
ll m, siz[mx][30], siz2[mx];
ll fpow(ll x, ll y) {
    ll tot = 1;
    for (; y; y >>= 1) {
        if (y & 1)
            tot = tot * x % mod;
        x = x * x % mod;
    }
    return tot;
}
void insert(int x) {
    int it = 1;
    for (int i = 29; i >= 0; i--) {
        int k = (x >> i) & 1;
        if (!trie[it][k])
            trie[it][k] = ++tot;
        it = trie[it][k];
        siz2[it]++;
        for (int j = 29; j >= 0; j--) {
            if ((x >> j) & 1) {
                siz[it][j]++;
            }
        }
    }
}
ll dfs1(ll x, ll y) {
    int it = 1;
    ll res = 0;
    for (int i = 29; i >= 0; i--) {
        //假如这一位答案为 1，则必须走相反边
        if (!it)
            break;  // 走没了
        int k = (x >> i) & 1;
        if ((y >> i) & 1) {
            it = trie[it][k ^ 1];
        }
        //否则计算相反边的答案
        else {
            res += siz2[trie[it][k ^ 1]];
            it = trie[it][k];
        }
    }
    res += siz2[it];  //记录剩下的贡献
    return res;
}
ll calc(int p, ll x) {
    ll res = 0;
    for (int j = 29; j >= 0; j--) {
        //如果 x 的这一位为 1，则加上为 0 的个数
        //将一个数拆分成每个数位的贡献
        if ((x >> j) & 1) {
            res = (res + (siz2[p] - siz[p][j]) * ((1 << j) % mod) % mod) % mod;
        } else {
            res = (res + siz[p][j] * ((1 << j) % mod) % mod) % mod;
        }
    }
    return res;
}
ll dfs2(ll x, ll y) {
    int it = 1;
    ll res = 0;
    for (int i = 29; i >= 0; i--) {
        if (!it)
            break;
        int k = (x >> i) & 1;
        if ((y >> i) & 1) {
            it = trie[it][k ^ 1];
        } else {
            int pos = trie[it][k ^ 1];
            res = (res + calc(pos, x)) % mod;

            it = trie[it][k];
        }
    }
    res = (res + calc(it, x)) % mod;
    return res;
}
int check(ll mid) {
    ll res = 0;
    for (int i = 1; i <= n; i++) {
        res += dfs1(a[i], mid);
    }
    return res;
}
ll check2(ll mid) {
    ll res = 0, cnt = 0;
    for (int i = 1; i <= n; i++) {
        //两个类似的函数
        cnt += dfs1(a[i], mid);
        res = (res + dfs2(a[i], mid)) % mod;
    }
    if (cnt > m)
        res = (res - (cnt - m) % mod * mid % mod) % mod;
    return (res + mod) % mod;
}
int main() {
    freopen("xor.in", "r", stdin);
    freopen("xor.out", "w", stdout);
    n = read(), m = read();
    m <<= 1;
    for (int i = 1; i <= n; i++) {
        a[i] = read();
        insert(a[i]);
    }
    ll L = 0, R = (1<<30) - 1, res;
    while (L <= R) {
        ll mid = (L + R) >> 1;
        if (check(mid) >= m)
            L = mid + 1, res = mid;
        else
            R = mid - 1;
    }
    printf("%lld", check2(res) * fpow(2, mod - 2) % mod);
}

C.

题意：给定一个序列，每次修改操作改变一个数的值，查询操作
询问 [l,r] 能否组成等差序列。 n,m<=3e5 。

solution：

我们考虑如何确定一个等差数列，等价于：

  1. 任意 i!=j ,a[i]!=a[j]
  2. 设等差序列最大值为 Max，最小值为 Min，则满足 (Max-Min)/k==r-l
  3. gcd(a[2]-a[1],a[3]-a[2],..,a[n]-a[n-1])==d

于是乎，我们可以用两个线段树维护区间最大最小值，和区间 gcd 。

对于判重的情况，我们 将值相同的数放入同一 set ，每次 lower_bound 查询最近的值相同的数 <l 即可。

#include <bits/stdc++.h>
#define PII pair<int, int>
#define int long long
using namespace std;
inline int read() {
    int X = 0;
    bool flag = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            flag = 0;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        X = (X << 1) + (X << 3) + ch - '0';
        ch = getchar();
    }
    if (flag)
        return X;
    return ~(X - 1);
}
// Task : 1. 补题   2. 写状压题解  3. 总结 dsu on tree  4. 补写 POI 试题
const int mx = 3e5 + 5;
int n, m, xo, num, a[mx], t2[mx << 2];
set<int> s[mx * 2];  // 类似于离散化
set<int>::iterator it;
map<int, int> ID;
// This code RE !
//算法：线段树
//维护：区间 gcd ，最小值，最大值，最近前缀
int gcd(int x, int y) { return (y == 0) ? x : gcd(y, x % y); }
struct SegmentTree {
    int val, Min, Max;
} t[mx << 2];
//找到 (x,y) 的前缀
int id(int x) {
    if (!ID[x])
        ID[x] = ++num;
    return ID[x];
}
int getpre(int x, int y) {
    it = s[id(y)].lower_bound(x);
    if (it == s[id(y)].begin())
        return 0;
    return *--it;
}
void up(int p) {
    t[p].val = max(t[p << 1].val, t[p << 1 | 1].val);
    t[p].Min = min(t[p << 1].Min, t[p << 1 | 1].Min);
    t[p].Max = max(t[p << 1].Max, t[p << 1 | 1].Max);
}
void update(int p, int l, int r, int x, int y) {
    if (l == r) {
        t[p].Min = t[p].Max = y;
        t[p].val = getpre(x, y);
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid)
        update(p << 1, l, mid, x, y);
    else
        update(p << 1 | 1, mid + 1, r, x, y);
    up(p);
}
//将第 x 位 gcd 修改为 y
void update2(int p, int l, int r, int x, int y) {
    if (l == r) {
        t2[p] = y;
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid)
        update2(p << 1, l, mid, x, y);
    else
        update2(p << 1 | 1, mid + 1, r, x, y);
    t2[p] = gcd(t2[p << 1], t2[p << 1 | 1]);
}
SegmentTree query(int p, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr)
        return t[p];
    int mid = (l + r) >> 1;
    if (qr <= mid)
        return query(p << 1, l, mid, ql, qr);
    if (mid < ql)
        return query(p << 1 | 1, mid + 1, r, ql, qr);
    SegmentTree t1 = query(p << 1, l, mid, ql, qr), t2 = query(p << 1 | 1, mid + 1, r, ql, qr), t3;
    t3.Max = max(t1.Max, t2.Max);
    t3.Min = min(t1.Min, t2.Min);
    t3.val = max(t1.val, t2.val);
    return t3;
}
int query2(int p, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr)
        return t2[p];
    int mid = (l + r) >> 1;
    if (qr <= mid)
        return query2(p << 1, l, mid, ql, qr);
    if (mid < ql)
        return query2(p << 1 | 1, mid + 1, r, ql, qr);
    int t1 = query2(p << 1, l, mid, ql, qr), t2 = query2(p << 1 | 1, mid + 1, r, ql, qr);
    return gcd(t1, t2);
}
signed main() {
    freopen("grade.in", "r", stdin);
    freopen("grade.out", "w", stdout);
    n = read(), m = read();
    for (int i = 1; i <= n; i++)
        a[i] = read(), s[id(a[i])].insert(i), update(1, 1, n, i, a[i]),
        update2(1, 1, n, i, abs(a[i] - a[i - 1]));
    for (int i = 1; i <= m; i++) {
        int op = read();
        if (op == 1) {
            int x = read(), y = read();
            x ^= xo, y ^= xo;
            if (a[x] == y)
                continue;
            //先删除之前的
            s[id(a[x])].erase(x);
            //再加入修改的
            a[x] = y;
            s[id(y)].insert(x);
            update(1, 1, n, x, y);
            //最后再来修改两个相邻位置的 gcd
            update2(1, 1, n, x, abs(a[x] - a[x - 1]));
            if (x + 1 <= n)
                update2(1, 1, n, x + 1, abs(a[x + 1] - a[x]));
        } else {
            int l = read(), r = read(), k = read();
            l ^= xo, r ^= xo;
            if(l > r) swap(l, r);
            if (l == r) {
                printf("Yes\n");
                xo++;
                continue;
            }
            if (k == 0) {
                SegmentTree tmp = query(1, 1, n, l, r);
                if (tmp.Min == tmp.Max) {
                    printf("Yes\n");
                    xo++;
                } else {
                    printf("No\n");
                }
                continue;
            }
            if (query2(1, 1, n, l + 1, r) != k) {
                printf("No\n");
                continue;
            }
            SegmentTree tmp = query(1, 1, n, l, r);
            if (tmp.val < l && (tmp.Max - tmp.Min) / k == r - l) {
                printf("Yes\n");
                xo++;
            } else {
                printf("No\n");
            }
        }
    }
}

D.

题意：有一个 n 序列，初始全为空，每次操作选取两个不同的数 +1 ，求 n 次操作后序列全为 2 的方案数。 n<=1e7 。

Solution:

该解法由巨佬 dj 提供。

经典递推。多项式数列。

设 dp[i] 表示 i 个数 i 次操作后全为 2 的方案数，f[i] 表示当前状态已有 2 个位置是 1 ，i-1 次后的方案数。f 数组为辅助数组,。

我们转移的目标 ： 先消除某一个格子。

  1. dp[i-2] * (i-2) * C(i,2) ，即 i 与 j 匹配。
    在这里插入图片描述
  2. f[i-1] * C(i-1,2) * A(i,2) ，即 i 分别与· j,k 匹配。

在这里插入图片描述

f[] 数组转移：

  1. dp[i-3] * (i-2) * A(i-1,2) ，即· j,k 分别与 i 匹配。

在这里插入图片描述
2. dp[i-2] * (i-1) ，即· j,k 互消。

在这里插入图片描述
3. f[i-2] * A(i-1,2) * A(i-2,2) ，注意配对有顺序。在这里插入图片描述

综上，时间复杂度 O(n) 。

总结：这种题的关键是抽象出模型，没有清晰的状态定义时最好不要侥幸推转移方程。必要时待定系数猜式子也是一法。（详见巨佬 ljs）。

#include <bits/stdc++.h>
#define ll long long
#define mod 998244353
using namespace std;
const int mx = 1e7 + 5;
inline int read() {
    int X = 0;
    bool flag = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            flag = 0;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        X = (X << 1) + (X << 3) + ch - '0';
        ch = getchar();
    }
    if (flag)
        return X;
    return ~(X - 1);
}
int n;
ll dp[mx], f[mx], res;
//转移的目标 ： 先消除某一个格子
// dp[i] = dp[i-2] * (i-1) * C(i,2) + f[i-1] * C(i-1,2) * A(i,2)
// f[i] = dp[i-2] * (i-1) + dp[i-3] * A(i-1,2) * (i-2) + f[i-2] * A(i-1,2) * A(i-2,2)
ll A(ll x) { return x * (x - 1) % mod; }
ll C(ll x) { return x * (x - 1) / 2 % mod; }
int main() {
    freopen("matrix.in", "r", stdin);
    freopen("matrix.out", "w", stdout);
    scanf("%d", &n);
    dp[0] = 1, dp[2] = 1;
    f[2] = 1;
    for (int i = 3; i <= n; i++) {
        dp[i] = (dp[i - 2] * (i - 1) % mod * C(i) % mod + f[i - 1] * C(i - 1) % mod * A(i) % mod) % mod;
        f[i] = (dp[i - 2] * (i - 1) % mod + dp[i - 3] * A(i - 1) % mod * (i - 2) % mod +
                f[i - 2] * A(i - 1) % mod * A(i - 2) % mod) %
               mod;
    }
    for (int i = 1; i <= n; i++) {
        res = (res + dp[i]) % mod;
    }
    printf("%lld", res);
}
仰望星空的蚂蚁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NOIP20221102模拟赛
海的那边是什么不重要了，结局可能不如你意，但希望尽你所能.
11-02 240
NOIP20221102模拟赛小总结
NOIP 2021 多校模拟赛
oi_521289的博客
11-09 473
NOIP 2021 多校模拟赛 难度不算特别大，能拿的分挺多，感觉也没啥反思的，T2代码太恶心了。 T1 串（string） 【题目背景】 形貌昳丽的西克是虱子国王嫡系军队的 general，同时也兼任虱子王国驻绿鸟国的外交官。 西克喜欢在蕉♂流群里与其它王国的使者蕉♂流，但前段时间由于说怪话被来自绿鸟国意识形态 不完全的国王驱♂逐出境。 西克非常愤怒，想要说出一句最怪的话，但他却忙于敢览求社的训练。 于是，他找到了你，无上尼特，想让你帮助解决他的问题。 【题目描述】 在虱子王国，一句话由 n 个词组成，
NOIP模拟题
11-06
NOIP2014冲刺模拟题，难度属于普及组，出题者RtPYH
noip模拟赛
10-18 90
T1 判断一个括号序列的位置$i$和$n-i+1$是否一样 暴力 T2 给一个长方体，每个点有权值，每次可以选一个子长方体减h 查询第几次操作后出现一个小于0的点 长方体体体积1e5 操作1e5 考虑二分答案，然后记录三维前缀和，check的时候直接操作mid次，看有没有小于0的就可以了 操作时三维差分，极端酸爽 T3 给n个人，每个人带的钱，他们一...
P7961 [NOIP2021] 数列 题解
yaosichengalpha的博客
06-28 745
P7961 [NOIP2021] 数列 题解
Noip2021模拟赛题解
Evan_song1234的博客
01-14 1022
我在校刷原来学长模拟赛题目时的题解
一次愚蠢的NOIP模拟赛
weixin_30614587的博客
08-21 165
找礼物[find.pas/find.c/find.cpp] 【问题描述】 新年到了，突然间，就在那美丽的一霎那，你好友和你（K个人）的周围满是礼物，你发扬你帅气的风格，让你的好友先拿，但是每个人只能拿当前离自己最近的礼物[当然如果有并列的多个礼物离你的距离相等（精确到小数后四位,所有运算均为去尾），这些礼物就都属于这个人]。现在你们所在的位置是原点(0,0)，每个礼物的位置用坐标...
NOIP模拟赛 试题
07-15
NOIP模拟赛试题是指为信息学奥林匹克竞赛（NOIP，National Olympiad in Informatics in Provinces）准备的模拟试题。信息学奥林匹克竞赛是中国面向高中生的一项计算机学科竞赛，旨在培养学生的逻辑思维和编程能力。...
noip模拟赛day1
10-28
【NOIP模拟赛Day1详解】——为竞赛之路铺砖添瓦 全国青少年信息学奥林匹克联赛（NOIP）是一项旨在发掘和培养青少年编程才能的重要赛事。对于参赛者来说，赛前的充分准备至关重要，尤其是模拟赛的参与，可以帮助考生...
拓扑，DP noip 模拟赛 [益智游戏] 题解
点击重新加载的博客
08-23 548
题目：益智游戏（！！！本题很卡时间！！！）题目描述： 小 P 和小 R 在玩一款益智游戏。游戏在一个正权有向图上进行。 小 P 控制的角色要从 A 点走最短路到 B 点，小 R 控制的角色要从 C 点走最短路到 D 点。 一个玩家每回合可以有两种选择，移动到一个相邻节点或者休息一回合。 假如在某一时刻，小 P 和小 R 在相同的节点上，那么可以得到一次特殊奖励，但是在每
noip模拟题
07-21
noip模拟题（有数据，有代码，有题解报告）
Loi Noip模拟赛
10-30
一个比较简单的模拟赛，内含day1day2，在考点和难度上与noip提高组相似。
NOIP模拟题——A
weixin_30338461的博客
11-10 128
AStatement给出一个长度不超过100只包含'B'和'R'的字符串，将其无限重复下去。比如，BBRB则会形成BBRBBBRBBBRB现在给出一个区间[l,r]询问该区间内有多少个字符'B'(区间下标从1开始)Input第一行为一个只包含'B'和'R'的字符串第二行为两个整数，表示l和rOutput输出[l,r]区间内字符'B'的数量Sample InputBBRB4 8Sample...
【学习笔记】NOIP模拟赛
cqbzlydd的博客
07-29 297
没想到啊没想到竟然不会写代码了
一本通冲刺 NOIP2021 模拟赛 B 组 Day3（2021.9.20）
欢迎您的光顾awa
09-24 260
摆烂了呢awa
[NOIP模拟][好题]Problem
千古的博客
10-12 692
题目描述： 今天豆豆在做作业的时候遇到这么一个问题： 给出 N 个正整数 a1..aNa_1..a_N ，再给出一个正整数 k ，现在可以进行如下操作：每次选择一个大于 k 的正整数 aia_i，将 aia_i 减去 1 ，选择 a[i-1] 或 a[i+1] 中的一个加上 1 。经过一定次数的操作后，最大能够选出多长的一个连续子序列，使得这个子序列的每个数都不小于 k 。 总共有 M 次
2024天梯赛模拟赛题解
最新发布
07-04
抱歉，关于"2024天梯赛模拟赛题解"的具体内容我没有现成的信息，因为它可能指的是某个特定的游戏、竞赛或者技术平台的问题解答，比如电子竞技比赛中的题目分析，或者是编程挑战中的模拟试题解析。通常这类信息会随着活动或赛事的举办而更新。 如果你是在询问某款游戏（如《英雄联盟》、《Dota 2》等）的天梯赛模拟题目的解答策略，那可能需要查看对应游戏社区的讨论、官方论坛或是第三方教学资源网站。对于编程相关的天梯赛模拟题，可能是数据结构和算法、LeetCode、Codeforces等平台的题目，你可以查阅这些平台的题解文章或视频教程。 若想获取准确的帮助，请提供更多的上下文或具体信息，以便我能给出更精确的答案。以下是几个可能的相关问题： 1. 这个“2024天梯赛”是指哪个游戏或技术比赛的名称？ 2. 题目类型是什么？例如，是编程题还是游戏战术题？ 3. 是否已经有实际的比赛日期或者模拟活动链接？ 请根据具体情况告诉我，我会尽力帮助你寻找相关信息。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值