中国石油大学校赛总结

传送门
原题解

C - 小菲爱数数

题目描述

小菲刚刚学完质数,所以她很喜欢计算一个整数有多少个质因子.每当小菲看到一些整数,她都会很快计算出这些数字的最小公倍数,然后数出最小公倍数有多少个质因子.

但是大菲觉得这太简单了,她决定考验一下小菲,让小菲计算出一个数组所有子数组最小公倍数的质因子数目之和.

小菲觉得这个问题太难了,所以她想问问你.

正式地讲,给出一个长度为n的数组$a_1$,$a_2$,$a_3$,⋯,$a_n$,请计算$\sum _{i=1}^n\sum _{j=i}^{n}f(lcm(a_{i\sim j}))$,其中f(x)表示x的质因子数目,lcm(b)表示数组b中所有元素的最小公倍数,$a_{l\sim r}$表示a中从l到r连续的一段子数组,即$a_l$,$a_{l+1}$,$a_{l+2}$,⋯,$a_r$

原数组中连续的一段区间内的元素组成的数组被称为原数组的子数组.例如[2],[2,3],[1,2,3,4]是[1,2,3,4]的子数组,但是[1,2,4]不是,因为不是连续的一段.

输入描述:

本题有多组测试数据.

第一行包含一行一个正整数$T(1\le T\le 10^4)$表示测试数据的数目,然后输入T组独立的数据.

每组数据第一行输入一行一个正整数$n(1\le n\le 2\times 10^5)$,表示数组的长度.

每组数据第二行输入以空格分隔的n个正整数,表示输入的数组$a_n(1\le a_i\le 10^6,1\le i\le n)$.

保证所有测试数据的n之和不超过$2\times 10^5$

输出描述:

对于每个测试样例,输出一行一个非负整数表示答案.

tag

思维

思路

对$a_{1\sim n}$分解质因子,考虑计算每个质因子对答案的贡献.

不妨设质因子$p$出现的位置有$b_1,b_2,b_3,\cdots ,b_k$,对于任意一个区间只要包含任意的$b_i$就会对答案产生$1$的贡献.

正难则反,我们可以计算有多少个区间不包含任何$b_i$,然后用总区间数减去不包含任何$b_i$的区间数得到质因子对答案的贡献.

显然只有处于任意两个相邻$b$之间的区间是不包含任何$b_i$的.

对于每个质因子我们先给答案加上$\frac{n(n+1)}{2}$,然后对于所有的相邻$b$之间的区间,假设长度为$len$,我们让答案减去$\frac{len(len+1)}{2}$.

当然,你可能需要通过加一些哨兵或者特判来解决边界问题.

根据分解质因子的方法不同,时间复杂度为$O(n\sqrt{A})$或者$O(n\log A)$.

因为含有多组测试样例,所以你需要用类似map或dict之类的关联容器来存储每个质因子出现的位置,以保证你枚举质因子的时间复杂度是$O(n\log A)$.

代码

#include<iostream>
#include<cstring>
#include<map>
#include<vector>
using namespace std;
using LL = long long;
int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    auto g = [](int x){
        return 1LL * x * (x + 1) / 2;
    };
    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        map<int, vector<int> > mp;
        for(int i = 1; i <= n; i++){
            int x;
            cin >> x;
            for(int j = 2; j * j <= x; j++){
                if (x % j == 0){
                    mp[j].push_back(i);
                    while(x % j == 0) x /= j;
                }
            }
            if (x > 1) mp[x].push_back(i);
        }
        LL ans = 0;
        for(auto &[x, v] : mp){
            ans += g(n);
            v.push_back(n + 1);
            int last = 0;
            for(auto u : v){
                ans -= g(u - last - 1);
                last = u;
            }
        }
        cout << ans << '\n';
    }
}

E - Construction Complete!

题目描述

指挥官想要在战场上建造一座新的生产建筑.

整个战场可以视为一个n行m列的二维网格,有一些网格中已经建造了一些生产建筑,还有一些网格是矿区,斜坡,悬崖等无法建造建筑的地方,剩下的位置是可以建造建筑的空地.

现在指挥官想建造一座新的占据r行c列网格的矩形建筑,但是必须要满足以下要求.

1. 建筑占据的所有网格都必须为空地.
2. 新的建筑必须在已有的建筑基础上延伸建造,即新建筑与距离其最近的已有建筑之间距离不能超过d.把第x行,第y列的网格的表示为(x,y)，则(x1,y1)与(x2,y2)之间的距离为$\left|x1-x2\right|+\left|y1-y2\right|$.

新矩形建筑与(x,y)之间的距离为矩形建筑占据的所有网格与(x,y)之间的距离中的最小值.

你是指挥官的顾问,现在指挥官想让你帮忙计算建造一座占据r行c列网格的矩形新建筑的方案数量.

对于两种方案,如果矩形新建筑最左上角的网格位置是不同的,则我们认为这两种建造方案是不同的.

输入描述:

本题含有多组测试数据,

第1行包含一行一个正整数T(1≤T≤$10^5$),表示测试数据的数目,然后输入T组独立的数据.

每组数据第1行输入一行五个以空格分隔的正整数n,m,r,c,d,分别表示战场的行数和列数,新建筑占据的行数和列数,以及已有建筑能延伸的最大距离.

数据范围满足2≤n⋅m≤$10^6$ , 1≤r≤n , 1≤c≤m,1≤d≤n+m−2.

接下来输入n行,每行m个字符表示战场的情况.第i行的第j个字符代表坐标为(i,j)的方格情况,如果字符是’x’,则表示该位置是已有的生产建筑,如果字符是’#‘则表示该位置是矿区,斜坡,悬崖等无法建造建筑的地方,如果字符是’.',则表示该位置是空地.

保证所有测试数据的n⋅m之和不超过$10^6$.

输出描述:

对于每组测试数据输出一行一个非负整数表示建造方案的数量.

tag

前缀和，BFS

思路

首先以所有的x为起点,用广度优先搜索(BFS)求取多源最短路$dist$.

对于任意一个矩形,首先要满足矩形内所有点都是空地,其次要满足矩形内存在一个$(x,y)$点满足$dis{t}_{x,y}\le d$.

对于第一个条件,我们令所有空地的位置为$1$,其他位置为$0$,然后处理出二维前缀和.查询时只需判断矩形和是否等于矩形面积即可.

对于第二个条件,我们令所有$dis{t}_{x,y}\le d$的点$(x,y)$为$1$,其他位置为$0$,同样处理出二维前缀和,查询时只需判断矩形和是否大于$0$即可.

然后就可以直接枚举矩形左上角的位置利用处理出的二维前缀和$O(1)$判断是否合法.时间复杂度和空间复杂度均为$O(\sum nm)$.

代码

#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
using LL = long long;
int main(){
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);
	const int dx[4] = {-1, 0, 1, 0};
	const int dy[4] = {0, -1, 0, 1};
	int T;
	cin >> T;
	while(T--){
		int n, m, r, c, dist;
		cin >> n >> m >> r >> c >> dist;
		vector<string> g(n + 1);
		for(int i = 1; i <= n; i++){
			g[i].resize(m + 1);
			for(int j = 1; j <= m; j++)
				cin >> g[i][j];
		}
		vector<vector<int> > d(n + 1, vector<int>(m + 1, n + m));
		queue<pair<int, int> > q;
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= m; j++)
				if (g[i][j] == 'x'){
					d[i][j] = 0;
					q.push({i, j});
				}
		while(!q.empty()){
			auto [x, y] = q.front(); q.pop();
			for(int u = 0; u < 4; u++){
				int nx = x + dx[u], ny = y + dy[u];
				if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
				if (d[nx][ny] < n + m) continue;
				d[nx][ny] = d[x][y] + 1;
				q.push({nx, ny});
			}
		}
		vector<vector<int> > s1(n + 1, vector<int>(m + 1, 0)), s2(n + 1, vector<int>(m + 1, 0));
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= m; j++){
				s1[i][j] = (d[i][j] <= dist) + s1[i - 1][j] + s1[i][j - 1] - s1[i - 1][j - 1];
				s2[i][j] = (g[i][j] == '.') + s2[i - 1][j] + s2[i][j - 1] - s2[i - 1][j - 1];
			}
		auto query = [&](const vector<vector<int> > &s, int x1, int y1, int x2, int y2){
			return s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1];
		};
		int ans = 0;
		for(int i = 1; i + r - 1 <= n; i++)
			for(int j = 1; j + c - 1 <= m; j++)
				if (query(s1, i, j, i + r - 1, j + c - 1) > 0 && query(s2, i, j, i + r - 1, j + c - 1) == r * c)
					ans++;
		cout << ans << '\n';
	}
}

F - 最小异或对

题目描述

给出一个多重集合(元素可以重复的集合),你需要提供以下操作:

1. ADD x,向多重集合里添加一个元素x,多重集合内元素可以重复
2. DEL x,从多重集合中删除一个元素x,保证要删除的元素一定存在,如果存在多个x则仅删除其中任意1个
3. QUE,查询集合中的最小异或对的值,即找到集合中任何两个元素(可以相等)异或能得到的最小值,保证询问时集合包含的元素数量不少于2个

对于每个QUE操作,你需要输出查询的结果.

以上操作中涉及的操作数x均为非负整数.

输入描述:

第一行输入操作的数量n(1≤n≤2×$10^5$),以下n行每行表示一个操作,操作的格式见题面.对于非负整数x满足$0\le x<2^{30}$.

输出描述:

对于每个QUE操作,输出一行一个非负整数,表示询问的答案.

tag

平衡树/01字典树

思路一

首先有一个结论,最小异或对一定是集合排序后相邻的数.

我们只需要证明对于任意的$a<b<c$,都满足最小值一定是$a\oplus b$或者$b\oplus c$,而不可能是$a\oplus c$.

满足这个条件后,如果我们选取的数在排序后的集合中不相邻,通过选相邻的数一定能使答案更小.

下面我们证明这个结论.

对于$a\oplus c$,找到其二进制表示中最高的为$1$的位为第$x$位,则$a$和$c$高于$x$的位一定相同,第$x$位一定不同,因为$a<c$,一定是$a$第$x$位为$0$,$c$第$x$位为$1$.

因为$a<b<c$,高于$x$的位$b$一定也和$a,c$都相同,$b$的第$x$位可能为$0$或者为$1$.

所以$a\oplus b$和$b\oplus c$中一定有一个数第$x$位为$0$,而$a\oplus c$第$x$位为$1$,即一定有一个数是小于$a\oplus c$的,由此结论得证.

所以我们需要维护原集合的有序序列和有序序列中所有相邻数字的异或值.

每次加入一个数$x$时,找到有序集合中$x$的前驱$pre$和后继$nxt$,在维护异或值的数据结构中删除$nxt\oplus pre$,加入$x\oplus pre$和$x\oplus nxt$.

删除一个数$x$时类似,删除$x$后同样找到$x$的前驱$pre$和后继$nxt$,加入$nxt\oplus pre$,删除$x\oplus pre$和$x\oplus nxt$即可.

每次查询输出所有相邻数字的异或值的最小值即可.

这要求我们需要快速找到有序序列中一个数字的前驱和后继,可以使用平衡树来维护.

用平衡树数维护原序列,然后使用一个支持增删和查询最小值的数据结构维护所有所有相邻数的异或值,同样可以使用平衡树.

当然你需要通过特判处理一些前驱或者后继不存在的情况.

增删查的时间复杂度均为$O(\log n)$总时间复杂度为$O(n\log n)$,空间复杂度为$O(n)$.

思路二

如果你不知道以上的结论,有另一种01Trie的做法.

从高位到低位建立01Trie,每个结点都维护$3$个信息:

1. 当前子树内能凑出的最小异或对的答案
2. 子树内的元素个数
3. 如果子树内只有一个元素,记录这个元素的值.

首先对于叶子结点,如果包含的元素数量不大于$1$,那么当前答案为无穷大,否则答案为$0$

在01Trie上,除了叶子结点外每个结点都有两个儿子.那么对于当前结点选取两个元素有$3$种可能,在左儿子中选取两个元素,在右儿子中选取两个元素,或者左右儿子各选一个元素.

如果能在同一个儿子里选择两个元素答案一定好于在两个儿子中各选一个元素,所以可以用儿子的答案更新当前结点.

如果两个儿子结点包含的元素数量都不大于$1$,那么我们只能在两个儿子中各选一个元素然后更新答案.

当然如果当前子树中包含的元素数量不大于$1$,答案为无穷大.

添加和删除时使用类似线段树的方式从下往上更新答案,每次查询时只需输出根节点的答案即可.

可以发现这里的01Trie完全等价于动态开点的权值线段树.

每次插入和删除的复杂度为01Trie的高度,查询的复杂度为$O(1)$,总的时间复杂度为$O(n\log A)$,空间复杂度也为$O(n\log A)$.

代码一

#include<iostream>
#include<cstring>
#include<set>
using namespace std;
using LL = long long;
int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    multiset<int> s, v;
    int n;
    cin >> n;
    while(n--){
        string op;
        cin >> op;
        if (op[0] == 'A'){
            int x;
            cin >> x;
            auto it = s.lower_bound(x);
            if (it != s.end())
                v.insert(*it ^ x);
            if (it != s.begin()){
                v.insert(*prev(it) ^ x);
            }
            if (it != s.begin() && it != s.end()){
                v.erase(v.lower_bound(*it ^ *prev(it)));
            }
            s.insert(x);
        }
        else if (op[0] == 'D'){
            int x;
            cin >> x;
            s.erase(s.lower_bound(x));
            auto it = s.lower_bound(x);
            if (it != s.end())
                v.erase(v.lower_bound(*it ^ x));
            if (it != s.begin()){
                v.erase(v.lower_bound(*prev(it) ^ x));
            }
            if (it != s.begin() && it != s.end()){
                v.insert(*it ^ *prev(it));
            }
        }
        else cout << *v.begin() << '\n';
    }
}

代码二

#include<iostream>
#include<cstring>
#include<vector>
#include<numeric>
#include<functional>
using namespace std;
using LL = long long;
const int maxn = 2e5 + 5, INF = 1 << 30;
struct Info {
    int dp, cnt, val;
    Info() : dp(INF), cnt(0), val(-1) {} 
    Info(int x) : dp(INF), cnt(1), val(x) {} 
    Info(int dp, int cnt, int val) : dp(dp), cnt(cnt), val(val) {}
}tr[maxn * 32];
int son[maxn * 32][2];
int root, idx;
Info operator+(const Info &a, const Info &b){
    Info ret = Info();
    ret.cnt = a.cnt + b.cnt;
    ret.dp = min(a.dp, b.dp);
    if (a.cnt == 1 && b.cnt == 1) ret.dp = a.val ^ b.val;
    if (ret.cnt == 1) ret.val = a.cnt ? a.val : b.val;
    return ret;
}
void insert(int &u, int x, int dep){
    if (!u) u = ++idx;
    if (dep == -1){
        ++tr[u].cnt;
        if (tr[u].cnt == 1) tr[u] = Info(x);
        else if (tr[u].cnt == 2) tr[u].dp = 0;
        return;
    }
    int bit = (x >> dep & 1);
    insert(son[u][bit], x, dep - 1);
    tr[u] = tr[son[u][0]] + tr[son[u][1]];
}
void del(int &u, int x, int dep){
    if (dep == -1){
        --tr[u].cnt;
        if (tr[u].cnt == 0) tr[u] = Info();
        else if (tr[u].cnt == 1) tr[u] = Info(x);
        return;
    }
    int bit = (x >> dep & 1);
    del(son[u][bit], x, dep - 1);
    tr[u] = tr[son[u][0]] + tr[son[u][1]];
}
int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    int n;
    cin >> n;
    int root = ++idx;
    while(n--){
        string op;
        cin >> op;
        if (op[0] == 'A'){
            int x;
            cin >> x;
            insert(root, x, 29);
        }
        else if (op[0] == 'D'){
            int x;
            cin >> x;
            del(root, x, 29);
        }
        else cout << tr[root].dp << '\n';
    }
}

G - 魔术卡片

题目描述

据说魔术卡片可以猜出你心中在想什么.

一组魔术卡片中每张卡片的大小和材料都是相同的,每张卡片上都有52个方格,其中每个方格都固定地对应某张扑克牌(不同的卡片上相同位置的方格对应的扑克牌是一样的),每张卡片上都会有一些扑克牌出现在这张牌对应的格子里(也有可能一些格子是空的).

因为卡片是半透明的,所以如果把一些卡片重叠到一起,我们就能看到所有在这些卡片中出现过的扑克牌.

魔术的表演方法是让观众心中想一张扑克牌,然后给他看这组魔术卡片,让观众描述每张卡片上是否有他心中所想的牌。接着表演者就可以准确地告知观众他心中想的是哪张扑克牌。

这是因为这组卡片有神奇的性质,如果把所有的不含有观众心中所想的数字的卡片叠在一起,那么只会有一张牌的位置上是空的,而这张牌就是观众心中所想的牌.

如图，把所有不含观众所想数字的魔术卡片重叠后,只有梅花8的位置是空的,所以观众心中想的牌是梅花8.

为了简化问题,我们现在让观众想一个1∼n的正整数,你需要设计一组卡片,能利用上文中提到的方法猜出观众心中想的数字,此外为了方便携带,卡片的数量不应该超过8张.

具体来讲就是你需要设计出一组不超过8张的卡片,每张卡片上都包含一些数字,要求对于任意的1≤i≤n都满足:假设所有不包含i的卡片上出现过的数字组成的集合为s,那么s包含1∼n中除了i以外的所有数字.

输入描述:

本题含有多组测试数据.

第1行包含一行一个正整数T(1≤T≤59),表示测试数据的数目,然后输入T组独立的数据.

每组数据输入一行一个正整数n(2≤n≤60),表示可能的观众心中所想数字的最大值.

输出描述:

对于每组测试样例数据,

第1行输出一个正整数m(1≤m≤8),表示卡片的数量.

第2∼m+1行每行输出一张卡片的内容,首先输出一个非负整数s(0≤s≤n)代表这张卡片上出现了多少个数字,然后
输出卡片上出现的s个正整数(1≤$x_i$≤n),每行数字之间以空格分隔.

如果存在多种可能的答案,输出其中任意一种都是正确的.

tag

构造

思路

对于$1\sim n$我们都用一个$8$位的二进制数表示其状态,第$i$位取$0/1$表示第$i$张卡片上是否有这个数字,然后我们考虑这些数之间需要具有怎样的性质.

对于任意数字$x$,假设其没有出现在第$c_1,c_2,c_3,\cdots$张卡片上,那么除了$x$以外的所有数字都至少在第$c_1,c_2,c_3,\cdots$上出现过一次.即第$c_1,c_2,c_3,\cdots$上至少有一位为$1$.所以所有除了$x$以外的数字的二进制表示一定不是$x$的子集.

推广到所有数字上,一定没有一个数字的二进制表示是另一个数字二进制表示的子集.所以我们只要找出一些二进制数,满足没有一个数是其他任何数的子集即可.

一种简单的构造方法是在所有$8$位的二进制数字里选取二进制表示中$1$的数量为$4$的数来构造,这些数显然不会有一个数是另一个数的子集.并且这样的数有$C_8^4=70$个,而$n\le 60$.

代码

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
using LL = long long;
int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    int T;
    cin >> T;
    while(T--){
        const int N = 8;
        int n;
        cin >> n;
        int cnt = 0;
        vector<vector<int> > ans(N);
        for(int i = 0; i < 1 << N; i++){
            if (__builtin_popcount(i) != 4) continue;
            if (++cnt > n) break;
            for(int j = 0; j < N; j++)
                if (i >> j & 1) ans[j].push_back(cnt);
        }
        cout << N << '\n';
        for(int i = 0; i < N; i++){
            cout << ans[i].size();
            for(auto x : ans[i]) cout << ' ' << x;
            cout << '\n';
        }
    }
}

H - 推队

题目描述

小菲最近在玩一款回合制精灵对战游戏,每只精灵都有体力,攻击,防御和速度四种属性,小菲的精灵初始的体力,攻击,防御和速度属性分别为$H_0$,$A_0$,$D_0$,$S_0$,初始的所有属性都为0级.

小菲她正准备用一只精灵击败对方的所有n只精灵,对方第i只精灵的体力,攻击,防御,速度属性分别为$h_i$,$a_i$,$d_i$,$s_i$.
在对战中小菲的精灵可以使用攻击技能或者属性技能,但是对方的精灵只能使用攻击技能.

使用攻击技能的效果可以对对方造成一定的伤害,让对方体力减少.假设攻击方的攻击为$a_{attacker}$​,被攻击方的防御为$d_{defender}$,则攻击方的攻击技能会让被攻击方体力减少$max(a_{attacker}-d_{defender},0)$.攻击技能没有次数限制可以无限次使用.

使用属性技能的效果是让己方精灵的攻击,防御,速度其中一项属性提升1级,小菲的精灵在攻击,防御,速度升到i级后相应的属性值分别变为$A_i$,$D_i$,$S_i$,每项属性最多升级到k级.

由于游戏有一些神奇的Bug(或者说是Feature),并不保证升级后的属性一定大于升级前的属性.

在一场对战中,她会按顺序挑战对方的n只精灵,一开始小菲的精灵和对方的第1只精灵同时登场并开始一个回合.
每一回合会按次序进行以下步骤

1. 比较双方精灵的速度决定哪方先出手,速度快的精灵先出手,如果双方速度相同则小菲的精灵先出手.
2. 先出手的精灵释放技能,技能的效果生效.
3. 后出手的精灵释放技能,技能的效果生效.

以上步骤中如果某次释放技能后导致小菲的精灵体力减少到0或更少,则小菲立即失败;如果释放技能导致对方的第i只精灵体力减少到0或更少,则对方的第i只精灵被击败退场,第i+1只精灵登场,如果第i+1只精灵不存在则小菲立即胜利.如果当前回合结束时没有精灵退场,那么开始下一个新的回合.

注意当对方精灵退场,新精灵登场或者新回合开始时小菲的精灵已损失的体力不会恢复,但已经强化的属性等级会保留.当有精灵退场时,当前回合立即结束,如有新精灵登场,则开始一个新的回合.

大菲帮小菲获得了对手的精灵资料,小菲想请你帮忙判断能否她能否推队(击败对手的所有n只精灵),如果能推队的话,她还想知道小菲的精灵最后最多能剩下多少体力.

输入描述:

本题有多组测试数据.

第1行包含一行一个正整数T(1≤T≤$10^4$),表示测试数据的数目,然后输入T组独立的数据.

每组数据第1行输入一行以空格分隔的两个非负整数n,k(1≤n≤$10^4$,0≤k≤3),表示对手的精灵数量和属性能强化到的最高等级.

第2行输入一行一个整数$H_0$,表示小菲的精灵的体力值.

接下来三行,每行输入k+1个以空格分隔的正整数,分别表示$A_{0-k},D_{0-k},S_{0-k}$(1≤$H_0$,$A_i$,$D_i$,$S_i$≤$10^9$),代表攻击,防御,速度这三个属性的初始值与升级后对应的值.

最后输入n行,每行输入4个正整数,表示对手第i只精灵的$h_i$,$a_i$,$d_i$,$s_i$(1≤$h_i$,$a_i$,$d_i$,$s_i$≤$10^9$),即第i只精灵的体力,攻击,防御,速度.

保证所有测试数据的n之和不超过$10^4$.

输出描述:

对于每组测试数据,输出一行一个整数表示答案.如果小菲不能推队,输出−1, 否则输出小菲的精灵最后击败对方的n只精灵后最多能剩下的体力值.

tag

dp

思路

我们用$d{p}_{i,a,b,c}$表示击退对手$i$只精灵,攻击等级为$a$,防御等级为$b$,速度等级为$c$时能剩余的最大体力,如果无法达到该状态则为$-1$.

考虑状态转移,因为$k$很小,所以我们可以枚举每种属性当前的等级和该回合准备给每个属性提升的等级进行转移.

关键在于计算某种策略下击败对手第$i$只精灵最少会损失多少体力.

虽然提升等级可能会导致属性值降低,但是我们可以发现在最优策略中,击败第$i$只精灵后每项属性一定不会低于对战第$i$只精灵之前的属性.

因为强化某项属性值但是使得这项属性降低对我们当前的对战是没有好处的,我们完全可以选择该回合强化到更高的属性值或者这回合不强化全部留到与对手下一只精灵对战时强化.这两种策略中一定至少有一种不劣于使某项属性值降低的策略.

所以当我们确定对战第$i$只精灵时,最优策略的操作顺序一定是先强化防御,然后强化攻击和速度,然后再使用攻击技能.

因为$k$很小,对于强化过程中受到的伤害我们可以直接暴力模拟,时间复杂度为$O(k)$,强化完之后属性值固定,可以$O(1)$计算.

总时间复杂度为$O(\sum n{k}^7)$.

代码

#include<iostream>
#include<cstring>
using namespace std;
using LL = long long;
const int maxn = 1e4 + 5;
int f[maxn][4][4][4];
int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    int T;
    cin >> T;
    while(T--){
        int n, k;
        cin >> n >> k;
        int H, A[4], D[4], S[4];
        cin >> H;
        for(int i = 0; i <= k; i++) cin >> A[i];
        for(int i = 0; i <= k; i++) cin >> D[i];
        for(int i = 0; i <= k; i++) cin >> S[i]
        for(int i = 0; i <= n; i++){
            for(int a = 0; a <= k; a++)
            for(int b = 0; b <= k; b++)
            for(int c = 0; c <= k; c++)
                f[i][a][b][c] = -1;
        }
        f[0][0][0][0] = H;
        for(int i = 0; i < n; i++){
            int h, a, d, s;
            cin >> h >> a >> d >> s;
            auto update = [&](int l1, int l2, int l3){
				int cur = f[i][l1][l2][l3];
                auto get = [&](int c1, int c2, int c3){
					int remain = cur;
                    for(int i = 1; i <= c2; i++){
						if (S[l3] >= s){
							remain -= max(0, a - D[l2 + i]);
							if (remain <= 0) return -1;
						}
						else{
							remain -= max(0, a - D[l2 + i - 1]);
							if (remain <= 0) return -1;
						}
					}
					if (A[l1 + c1] <= d) return -1;
					int dec1 = max(0, a - D[l2 + c2]);
					int dec2 = A[l1 + c1] - d;
					if (1LL * (c1 + c3) * dec1 >= remain) return -1;
					if (dec1 == 0) return remain;
					remain -= (c1 + c3) * dec1;
					int cnt = (h + dec2 - 1) / dec2 - (S[l3 + c3] >= s);
					if (1LL * cnt * dec1 >= remain) return -1;
					remain -= cnt * dec1;	
					return remain;
                };
                for(int c1 = 0; c1 <= k - l1; c1++)
                for(int c2 = 0; c2 <= k - l2; c2++)
                for(int c3 = 0; c3 <= k - l3; c3++)
                    f[i + 1][l1 + c1][l2 + c2][l3 + c3] = max(f[i + 1][l1 + c1][l2 + c2][l3 + c3], get(c1, c2, c3));
            };
            for(int a = 0; a <= k; a++)
            for(int b = 0; b <= k; b++)
            for(int c = 0; c <= k; c++)
                if (f[i][a][b][c] > 0)
                    update(a, b, c);
        }
        int ans = -1;
        for(int a = 0; a <= k; a++)
        for(int b = 0; b <= k; b++)
        for(int c = 0; c <= k; c++)
            ans = max(ans, f[n][a][b][c]);
        cout << ans << '\n';
    }
}

I - 最大公约数求和

题目描述

给定非负整数n,k, 请计算$\sum _{i=1}^n(gcd(i,k)\cdot i^k)(mod1000000007)$.

其中x mod m表示x除以m的余数,gcd(a,b)表示a和b的最大公约数.

注意对于任意正整数x,均有gcd(x,0)=x.

输入描述:

输入一行以空格分隔的两个非负整数n,k(1≤n≤2×$10^7$,0≤k≤$10^{18}$),请注意n的数据范围.

输出描述:

输出一行一个非负整数代表$\sum _{i=1}^n(gcd(i,k)\cdot i^k)(mod1000000007)$的结果.

tag

积性函数

思路一

$f(x)=x^k$与$g(x)=\gcd (x,k)$都是积性函数,可以在线性筛的过程中计算.

当$x$为质数,直接计算$f(x)$与$g(x)$,计算这两个函数的复杂度都为$O({\log }_{2}k)$.

当$x$为合数,在线性筛的过程中,$x$会被其最小质因子筛掉,设其最小质因子为$p$.

$f(x)=x^k$是完全积性函数,因此有$f(x)=f(p)\cdot f(\frac{x}{p})$.

对于$g(x)=\gcd (x,k)$,只需判断是否有$\frac{k}{g(\frac{x}{p})}\equiv 0(\mathrm{mod}p)$,如果是则$g(x)=p\cdot g(\frac{x}{p})$,否则$g(x)=g(\frac{x}{p})$.

质数密度$\pi (n)\approx \frac{n}{\ln n}$,所以总时间复杂度为$O(\frac{{\log }_{2}k}{\ln n}\cdot n+n)\approx O(n)$.

思路二

$f(x)=x^k$很容易发现是积性函数,但是观察到$g(x)=\gcd (x,k)$是积性函数还是有一定难度的.

$f(x)=x^k$通过解法$1$中的方式计算.

而对于$g(x)=\gcd (x,k)$,我们发现$g(x)$的取值是非常有限的,只可能是$k$小于等于$n$的因子.因此我们可以枚举所有因子的倍数更新$g(x)$的值.

枚举$1\sim n$所有倍数的时间复杂度是$O(n\log n)$,但因为$k$的因子在$1\sim n$中的分布是非常稀疏的,所以实际复杂度远小于这个上界,时间复杂度不明,但足以通过本题.

代码

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 2e7 + 5, mod = 1e9 + 7;
typedef long long LL;
int primes[maxn], cnt;
int x[maxn], g[maxn];
bool isPrime[maxn];
int qpow(int a, int b, int mod){
    int res = 1;
    while (b){
        if (b & 1) res = 1LL * res * a % mod;
        a = 1LL * a * a % mod;
        b >>= 1;
    }
    return res;
}
int f(int n, LL k){
    int res = 1;
    int up = k % (mod - 1);
    for(int i = 2; i <= n; i++){
        if (!isPrime[i]){
            primes[cnt++] = i;
            x[i] = qpow(i, up, mod);
            g[i] = __gcd(1LL * i, k);
        }
        for(int j = 0; i * primes[j] <= n; j++){
            isPrime[i * primes[j]] = 1;
            x[i * primes[j]] = 1LL * x[i] * x[primes[j]] % mod;
            if (i % primes[j] == 0){
                g[i * primes[j]] = g[i];
                if ((k / g[i]) % primes[j] == 0) g[i * primes[j]] *= primes[j];
                break;
            }
            g[i * primes[j]] = g[i] * g[primes[j]];
        }
        res = (res + 1LL * g[i] * x[i]) % mod;
    }
    return res;
} 
int main(){
    int n; LL k;
    cin >> n >> k;
    cout << f(n, k) << '\n';
}