2021年暑假牛客多校第一场 | 总结

最新推荐文章于 2021-08-06 18:37:58 发布
最新推荐文章于 2021-08-06 18:37:58 发布
阅读量317 收藏
点赞数 1
分类专栏： 2021牛客多校
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mldl_/article/details/119034622
版权

比赛链接：https://ac.nowcoder.com/acm/contest/11166
菜狗，大佬勿喷

简单题解

A. Alice and Bob | 博弈论 | sg函数

题目大意：

两人博弈。有两堆石头，每次一个人从一堆中拿 k 个，同时从另一堆拿 k * s(s >= 0) 个，问谁先不能拿。
数据均不大于 5000。

思路：

规定：一堆石头有 n 个，另一对石头有 m 个

  • 第一点：可以证明，对于 n 的每一个值，只有一个对应的 mx 使得（n，mx）构成必败态
    证明：如果(n, m1) 和 (n, m2 ) 都是必败态，先手第一次在第二堆取 | m1 - m2 | 个石头的话，后手会面对(n, m2 ) 的局面。这时发生冲突，(n, m1) 的必败态就不成立。
  • 第二点：显然 (0，0) 是必败态，O(N2) 处理出所有局面的，O( 1 ) 查询即可
  • 补充：本题显然，能到达必败态的局面都是必胜态

AC代码：

#include <bits/stdc++.h>
#define ll long long
const int maxn = 1e5 + 5;
using namespace std;		

bool sg[5001][5001];

int main(){
	
	for(int i = 0; i <= 5000; i++){
		for(int j = 0; j <= 5000; j++){
			if(sg[i][j] == 0){ // 拿一次就可以到达必败态的局面就是必胜态
				for(int k = 1; i+k <= 5000; k++){
					for(int s = 0; j+s*k <= 5000; s++){
						sg[i+k][j+s*k] = 1;
					}
				}
				for(int k = 1; j+k <= 5000; k++){
					for(int s = 0; i+s*k <= 5000; s++){
						sg[i+s*k][j+k] = 1;
					}
				}
			}
		}
	}
	
	int ncase;
	scanf("%d", &ncase);
	while(ncase--){
		int n, m;
		scanf("%d %d", &n, &m);
		if(sg[n][m]) cout << "Alice" << endl;
		else cout << "Bob" << endl;
	}
	
	return 0;
}

B. Ball Dropping | 简单计算几何

题目大意：

给出 a 、b、h 和 r ，求标红线段的长度，如果小球会掉下去，输出 Drop。
此图来自牛客

思路：

初中数学题，相似三角形比一下就出来了。
注意一种情况，如图
在这里插入图片描述

AC代码：

#include <bits/stdc++.h>
#define ll long long

using namespace std;		

int main(){
	double r, a, b, h;
	scanf("%lf %lf %lf %lf", &r, &a, &b, &h);
	if(2.0 * r < b){
		printf("Drop\n");
	}else{
		double x = 1.0 * (b * h) / (a - b);
		double y = sqrt((x * x) + b * b / 4.0);
		double z = 2.0 * r * y / b;
		double res = z - x;
		printf("Stuck\n");
		printf("%.10lf\n", res);		
	}


	return 0;
}

C. Cut the Tree | 线段树 |未补

是一个很难的线段树，未补

D. Determine the Photo Position | 签到

题目大意：

给出 n * n 的 01 矩阵，用 1*m 的矩阵覆盖一段 0(不能旋转)，输出可行的方案数

思路：

每一行处理一个前缀和，计算 0 的个数，然后查询即可

AC代码：

#include <vector>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#define ll long long
#define chushi(a, b) memset(a, b, sizeof(a))
#define endl "\n"
const double eps = 1e-8;
const ll INF=0x3f3f3f3f;
const int mod=998244353;
const int maxn = 1e5 + 5;
using namespace std;

int ma[2005][2005];
char s[2005];

int main(){
	
	int n, m;
	cin >> n >> m;
	char c;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			cin >> c;
			if(c == '1') ma[i][j] = 0;
			else ma[i][j] = 1;
		}
	}
	cin >> s;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			ma[i][j] += ma[i][j-1];
		}
	}
	
	int res = 0;
	for(int i = 1; i <= n; i++){
		for(int j = m; j <= n; j++){
			if(ma[i][j] - ma[i][j-m] == m) res++;
		}
	}
	cout << res << endl;
	
	
	return 0;
}

E. Escape along Water Pipe | BFS和DFS

题目大意：
给出一个 n * m 的水管图，要从 (1,1) 顶部走到 (n,m) 底部。每走一步前，可以选择一个管道集合旋转相同的角度(0，90，180，270)。要求在 20nm 步前走到终点或者输出无解。

思路：

麻烦的搜索题，/(ㄒoㄒ)/~~

  • 第一点：先 BFS ，看是否存在一个合法的路径。在 BFS 时，可以先不考虑水管如何旋转，用 (x, y, d) 表示一个状态，即从 d 方向进入(x, y)。同时，记录一下是由那个状态进入到 (x, y, d) 中，递归路径用。
  • 第二点：本题是默认由 (0, 1) 进入(1, 1), 并且要求能从 (n,m) 到 (n+1,m)。看图就会明白：此图来自牛客
  • 第三点：由 (x, y, d) 和 pre[(x, y, d)] 可以知道进入(x, y) 的上一个管道的形状 (进入管道方向和离管道的方向就决定了管道的摆放方式)
  • 第四点：如果有达到(n+1, m, 0)状态的，即存在一种方案，DFS找路径即可
  • 第五点：一个管道会被从不同时候进入多次，故而，这个管道可能被旋转多次，敲黑板！！！

AC代码：

#include <stdio.h>
#include <vector>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#define ll long long
#define chushi(a, b) memset(a, b, sizeof(a))
#define endl "\n"
const double eps = 1e-8;
const ll INF=0x3f3f3f3f;
const int mod=1e9 + 7;
const int maxn = 1e6 + 5;
const int N=1005;
using namespace std;

typedef struct Node{
	int x;
	int y;
	int d;
} node;

int ma[1005][1005];
bool vis[1005][1005][4]; // 已经到达过这个状态 
node pre[1005][1005][4]; // 到达这个状态上一个状态的信息 
int n, m;
queue<node> qu;
// 0	1	 2	  3
// ↓	←	 ↑	  →

bool check(int x, int y, int d){
	if(x == n+1 && y == m && d == 0) return true;
	if(x < 1 || x > n || y < 1 || y > m) return false;
	if(vis[x][y][d]) return false;
	return true;
}

void push(int x, int y, int d, int xx, int yy, int dd){
	pre[xx][yy][dd].x = x; pre[xx][yy][dd].y = y; pre[xx][yy][dd].d = d;
	qu.push({xx, yy, dd});
}

void bfs(){
	qu.push({1, 1, 0});
	while(!qu.empty()){
		int x = qu.front().x, y = qu.front().y, d = qu.front().d;
		qu.pop();
		if(vis[x][y][d]) continue;
		vis[x][y][d] = 1;
		if(x == n+1 && y == m && d == 0) break;
		if(ma[x][y] > 3){
			if(d == 0 && check(x+1, y, d))		push(x, y, d, x+1, y, d);
			else if(d == 1 && check(x, y-1, d)) push(x, y, d, x, y-1, d);
			else if(d == 2 && check(x-1, y, d)) push(x, y, d, x-1, y, d);
			else if(d == 3 && check(x, y+1, d)) push(x, y, d, x, y+1, d);
		}
		else{
			if(d == 0 || d == 2){
				if(check(x, y-1, 1)) push(x, y, d, x, y-1, 1);
				if(check(x, y+1, 3)) push(x, y, d, x, y+1, 3);
			}
			else{
				if(check(x+1, y, 0)) push(x, y, d, x+1, y, 0);
				if(check(x-1, y, 2)) push(x, y, d, x-1, y, 2);
			}
		}
	}
	while(!qu.empty()) qu.pop();
}

int get_id(int x, int y, int d){
	int dd = pre[x][y][d].d;
	if(dd == d) return d % 2 == 0 ? 5 : 4;
	if(dd == 0) return d == 1 ? 0 : 1;
	if(dd == 1) return d == 2 ? 1 : 2;
	if(dd == 2) return d == 3 ? 2 : 3;
	if(dd == 3) return d == 2 ? 0 : 3;
}

void dfs(int x, int y, int d, int step){
	if(x == 1 && y == 1 && d == 0){
		cout << "YES" << endl;
		cout << step*2 << endl;
		return;
	}
	dfs(pre[x][y][d].x, pre[x][y][d].y, pre[x][y][d].d, step+1);
	int n_id = get_id(x, y, d);
	int id = ma[pre[x][y][d].x][pre[x][y][d].y];
	cout << "1 " << (n_id - id + 4) % 4 * 90 << " " << pre[x][y][d].x << " " << pre[x][y][d].y << endl;
	ma[pre[x][y][d].x][pre[x][y][d].y] = n_id; // 注意修改管道的状态，会多次进入
	cout << "0 " << pre[x][y][d].x << " " << pre[x][y][d].y << endl;
}

int main() {
	
	int ncase;
	cin >> ncase;
	
	while(ncase--){
		
		cin >> n >> m;
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= m; j++){
				cin >> ma[i][j];
			}
		}
		
		bfs();
		
		if(vis[n+1][m][0]) dfs(n+1, m, 0, 0);
		else cout << "NO" << endl;
		for(int i = 1; i <= n+1; i++){
			for(int j = 1; j <= m; j++){
				for(int k = 0; k < 4;  k++){
					vis[i][j][k] = 0;
				}
			}
		}
	}
	
	return 0;

}

F. Find 3-friendly Integers | 抽屉原理

题目大意：
定义一个自然数是 3-friendly 的，如果它存在一个子串（允许前导0）是 3 的倍数。多组数据，求 (L, R) 中 3-friendly 的数的个数(闭区间)。
数据范围：1e18

思路：

在 0 到 9 中 mod 3 的结果只有 0、1 和 2。根据抽屉原理，三位数的以后的所有数字都是 3-friendly。
证明：

  • 数位中存在 mod 3 = 0 的数直接就是 3-friendly 数字；
  • 如果不存在 mod 3 = 0 的数字，可能情况有：111，222，112，121，221，212。可以发现，全部满足 3-friendly的定义。

其他数字暴力即可
AC代码：

#include <vector>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#define ll long long
#define chushi(a, b) memset(a, b, sizeof(a))
#define endl "\n"
const double eps = 1e-8;
const ll INF=0x3f3f3f3f;
const int mod=998244353;
const int maxn = 1e5 + 5;
using namespace std;

ll f(ll x){
	if(x == 0) return 0;
	ll res = 0;
	for(int i = 1; i <= min(x, 99ll); i++){
		if(i % 3 == 0) res++;
		else if(i%10%3 == 0) res++;
		else if(i > 9 && i/10%3 == 0) res++;
	}
	if(x > 99) res += x - 99;
	return res;
}

int main(){
	
	int ncase;
	cin >> ncase;
	
	while(ncase--){
		ll l, r;
		cin >> l >> r;
		ll res = f(r) - f(l-1);
		cout << res << endl;
	}

	return 0;
}

G. Game of Swapping Numbers | 思维、对绝对值的理解

题目大意：

给定序列 A,B，需要交换恰好 k 次 A 中两个不同的数，使得 A,B 每个位置的绝对差值和最大。
数据范围：N <= 100000

思路：
我是没太理解讲解人给出的方法，想了另外的方法解决这个题

  • 第一点：在一维的数轴上，| a - b | 表示线段ab的长度
  • 第二点：可以把 | ai - bi | 当作线段 aibi 的长度，这个题就转化为，可以交换一些线段的端点，让所有的线段长度和大
  • 第三点：没有相交的两个线段，交换点之后，长度一定变长，如图
    在这里插入图片描述
  • 第四点：显然，增加的线段长度为：2 * ( min(a2, b2) - max(a1, b1) )
  • 第五点：根据贪心，取前 k 大的 2 * ( min(ax, bx) - max(ay, by) ) 即可
  • 第六点：如果没有相交的线段不足 k 个，我们随意交换其他的线段，把多的交换次数浪费掉就好，保持最优

AC代码：

#include <bits/stdc++.h>
#define ll long long
const int maxn = 1e6 + 5;
using namespace std;		

int a[maxn];
int b[maxn];

int main(){
	
	int n, k;
	cin >> n >> k;
	for(int i = 1; i <= n; i++) cin >> a[i];
	for(int i = 1; i <= n; i++) cin >> b[i];
	// 让 a 中为 min(a, b)，b 中为 max(a, b)
	for(int i = 1; i <= n; i++) if(a[i] > b[i]) swap(a[i], b[i]);
	// 计算出所有线段长度
	ll sum = 0;
	for(int i = 1; i <= n; i++) sum += b[i] - a[i];
	// 排序
	sort(a+1, a+1+n);
	sort(b+1, b+1+n);
	// 取前 k 长
	for(int i = 1; i <= k && i <= n; i++){
		if(a[n+1-i] > b[i]){
			sum += 2 * (a[n+1-i] - b[i]);
		}
	}
	
	cout << sum << endl;
	
	return 0;
}

H. Hash Function | 数学、FFT

题目大意：
给定 n 个互不相同的数，找一个最小的模域，使得它们在这个模域下互不相同。
数据范围：所有数小于 500000，保证 a[i] != a[j]

思路：

这个题是队友补的，FFT 我不会，/(ㄒoㄒ)/~~

  • 第一点：如果 a % mod != b % mod，则 | a - b | % mod != 0
  • 第二点：问题转化，计算任意两个数差值，找到不能被这些差整除的第一个数就是答案
  • 第三点：任意两个数差值，朴素做法是 O(N2)，需要用 FFT / NTT 加速到 O(logn * n)

AC代码：

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 2e6+10;

const double PI = acos(-1);

int p[maxn], ans[maxn];

struct Complex{
    double x, y;
    Complex (double x = 0, double y = 0) : x(x), y(y) { }
}a[maxn], b[maxn];

Complex operator * (Complex J, Complex Q) {
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator - (Complex J, Complex Q) {
    return Complex(J.x - Q.x, J.y - Q.y);
}
Complex operator + (Complex J, Complex Q) {
    return Complex(J.x + Q.x, J.y + Q.y);
}

int R[maxn];
int bit, tot;
//FFT板子
void FFT(Complex *A, int type){
	//按照R数组对A数组进行实际排序 
    for(int i = 0; i < tot; ++ i)
        if(i < R[i]) 
			swap(A[i], A[R[i]]);//if保证只换一次 

    for(int mid = 1; mid < tot; mid <<= 1) {
        Complex wn({cos(PI / mid), type * sin(PI / mid)});

        for(int pos = 0; pos < tot; pos += mid*2) {
            Complex w(1, 0);

            for(int k = 0; k < mid; ++ k, w = w * wn) {
                Complex x = A[pos + k];
                Complex y = w * A[pos + mid + k];
                A[pos + k] = x + y;
                A[pos + mid + k] = x - y;
            }
        }
    }
}

int main(){
	int n;
    scanf("%d",&n);
    int maxx = 0;
    for(int i=0; i<n; i++){
    	scanf("%d",&p[i]);
    	maxx = max(maxx, p[i]);
	}
	for(int i=0; i<n; i++){
		a[p[i]].x = 1;
		b[maxx - p[i]].x = 1;
	}
	while((1<<bit) <= 2*maxx) bit++;
	tot = 1<<bit;
	
	for(int i=0; i<tot; i++){
		R[i] = (R[i >> 1] >> 1) | ((i & 1) << (bit - 1));
	}
	
	FFT(a, 1); FFT(b, 1);
	
	for(int i = 0; i < tot; ++i)
        a[i] = a[i] * b[i];
        
    FFT(a, -1);
    
    for(int i=1; i<=maxx; i++){
    	ans[i] = (int)(a[i+maxx].x / tot + 0.5);
	}
	
    for(int i=1; i<= maxx+1; i++){
    	int f = 1;
    	for(int j=i; j<=maxx; j+=i){
    		if(ans[j]){
    			f = 0;
			}
		}
		if(f){
			printf("%d\n", i);
			break;
		}
	}
    
	return 0; 
}

I. Increasing Subsequence | 期望DP | 未补

J. Journey among Railway Stations | 线段树

题目大意：
一段路上有 N 个点，每个点有一个合法时间段 [ui, vi]，相邻两个点有一个长度。每次问，从任意时刻出发，是否可以以此到达 [ l, r ] 之间的所有点，使得到达时间满足每个点的合法区间（如果提前到可以等待，迟到了就失败）。同时还可能修改一段路的长度，或者修改一个点的合法时间段。

思路：

用线段树维护信息即可，每一个叶子节点 x 表示：第 x 个点是否合法，以及它的合法区间。
则对应的区间节点 (l, r) 表示：通过区间(l, r) 是否合法，以及它的合法区间
具体细节就看代码吧

AC代码：

代码链接，无语子，放线段树的代码说与其他文字大量重复
https://pasteme.cn/139596

K. Knowledge Test about Match | 乱搞

题目大意：

随机生成一个权值范围为 0 ~ n-1 的序列，你要用 0 ~ n-1 去和它匹配，匹配函数是 sqrt。
要求平均情况下和标准值偏差不能超过 4%。

思路：

乱搞的，出题人都说是乱搞的

AC代码：

#include <bits/stdc++.h>
#define ll long long
const int maxn = 1e5 + 5;
using namespace std;		

int a[maxn];
double s[maxn];

int main(){
	
	for(int i = 1; i < maxn; i++) s[i] = sqrt(1.0*i);
	
	int ncase;
	cin >> ncase;
	
	while(ncase--){
		int n;
		cin >> n;
		for(int i = 0; i < n; i++) cin >> a[i];
		for(int i = 1; i <= 5; i++){
			for(int j = 0; j < n; j++){
				for(int k = j+1; k < n; k++){
					if(s[abs(j-a[j])] + s[abs(k-a[k])] > s[abs(j-a[k])] + s[abs(k-a[j])]){
						swap(a[j], a[k]);
					}
				}
			}
		}
		for(int i = 0; i < n; i++) cout << a[i] << " ";
		cout << endl;
	}
	
	return 0;
}

总结

A题：博弈论优先考虑四大基础博弈，再者是 SG函数，再往后就是纯思维博弈
D题：区间查询问题：前后缀、差分、二分、双指针尺取、线段树 或 树状数组、莫队 或 分块
E题：这个题和之前写过的题最大的区别在于：一个点会有很多状态，之前写过的题一个点一般都只有一个状态。直接 wa 成傻子，┭┮﹏┭┮
F题：1e18 的数据范围，必有公式或结论
G题：对于绝对值的理解，考虑它的几何意义。出题人题除的符号分配也是很好的模型。
H题：a 和 b 模 m 结果相同，有 | a - b | % m = 0。
J题：线段树初成长~~

mldl_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【牛客多校20210717 Cut the Tree】【长链剖分】
beginend
07-20 382
(我是superguymj，因为没有blog，所以就发到这来了。感谢beginend的友情铺位) 简单题意 给一颗树，定义 f(x)f(x)f(x) 为删除点 xxx 后的森林的树上最长上升子序列，求最小的 f(x)f(x)f(x)。 题解 题解看不懂，时间复杂度还劣，所以自己写一篇。 首先考虑如何算子树内的树上最长上升子序列。经典做法是维护一个上升和下降的单调栈，每次合并就是把两个单调栈点积取 min/max。 注意单调栈的长度是 O(depth)O(depth)O(depth) 的，所以长剖即可。复杂度
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
1. 后缀数组(B-Suffix Array): 后缀数组是一种数据结构，用于高效地处理字符串的子串查询。B-Suffix Array是基于字符间的最小距离构建的，它等价于由字符间最小距离数组构成的后缀数组。在文本搜索和字符串处理问题...
CF1120B casino题解
wangyuda123456789的博客
09-05 222
题目大意：给定两个序列A，B（0<=A[i],B[i]<=9），你可以做一个操作x，使A[x]+1,A[x+1]+1或使A[x]-1,A[x+1]-1，（0不能-1,9不能+1）使得A=B，若可以请输出操作方案（大于1e5时输出1e5行），不可以输出-1 题解：这是作业里很水的一道题了。 首先我们先判可行性，直接从前到后贪心即可。 但是输出方案就有一些问题。对于操作x，A[x+1]=0时不能-1,=9时不能+1，考虑如何完成这个操作。 以A[x+1]=0为例，我们就对x+1进行+1操作，然后对x
2021牛客多校1——C：Cut the Tree（点分治，数的重心，树上最长上升子序列，动态权值线段树）
kunyuwan的博客
07-27 550
题面 题意： 给一个带点权的树，你可以删去树上一个点，最小化所有子树最长上升子序列的长度最大值 。N <= 100000 前置知识： 树的重心 点分治 权值线段树 动态开点 参考资料 树分治 - OI Wiki (oi-wiki.org) 『权值动态开点线段树』『线段树合并算法』简单理解_Ronaldo7_ZYB的博客-CSDN博客_权值线段树合并 【AgOHの算法胡扯】点分治_哔哩哔哩_bilibili 思路: 要最小化所有子树的最长上升子序列的最大值，我们可以每次取这棵带权树的重心.
2020牛客暑假多校训练营 (第七场) B,D,H,J
hhhcbw的博客，欢迎各位来访
08-04 219
B Mask Allocation 递归，有n*m个口罩，我们可以发现最优策略是每次从中选min(n,m)*min(n,m)，假设选的是m*m,那么此时还剩(n-m)*m个口罩,这样我们就把问题分解成了一个更小的问题，递归求解即可。 #include <iostream> #include <stdio.h> #include <vector> using namespace std; const int maxn=1e7+5; int T; int n,m; vecto
2021牛客暑期多校训练营1 赛后总结
Fau的博客
07-18 458
比赛名称: 2021牛客暑期多校训练营1 比赛时间: 2021年7月17日 12:00 - 17:00 比赛结果: 3/11 自我总结: 这场比赛应该算是这个假期的第二场团队赛了, 之前打过一个比较简单的比赛, 不过那次并没有打比赛的感觉(多方面原因吧). 比赛结果结果其实挺拉垮的. 我悄悄的看了眼去年第一场多校, 3885人报名, 而今年有4423人报名. 不得不说竞争压力确实越来越大了. 做题分析: 首先习惯性的把所有题都点了一遍, 最开始我猜D G H应该是签到, 我先去看了H, 凡好像去看了B(几何
2020牛客多校暑期集训营第一场题解.pdf
01-20
### 2020牛客多校暑期集训营第一场题解 #### B-SuffixArray 在构建**B-SuffixArray**时，首先要理解**C_i**的定义：对于字符串**s**中的每一个位置**i**，找到第一个与**s_i**相同且位置大于**i**的位置**j**，...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2021牛客暑期多校第一场A题（爱丽丝和鲍勃）题解
keguaiguai的博客
08-06 1081
题目大意 有一种石子游戏，爱丽丝先手，爱丽丝和鲍勃轮流操作。有两堆石子，每次可以从一堆石子中取出k（k>0）个，并且从另一堆石子中取出s×k（s≥0）个。谁不能进行操作谁就输了。如果爱丽丝和鲍勃足够聪明，给出石子数量，问谁会赢。数据范围：每堆石子数量在0~5000之间，有10000次以内的询问。 样例输入 5 2 3 3 5 5 7 7 5 7 7 样例输出 Bob Alice Bob Bob Alice 思路 这是一道博弈问题，在纸上推算一定数目的样例找不到规律，因此使用SG函数利用计算机的高性
2021牛客暑假多校联赛第一场
qq_45398885的博客
07-29 200
声明：题意就不细说了，我这功底说的也语句不通，尽量写好题解，大家由疑问可以私信我，我会及时回复的，此篇题解是作者在看了网上众多题解之后，自己的一些感受。 A. Alice and Bob 说实话，这题比赛的时候是真的不会，和队友讨论了一下，感觉就情况很多，然后很复杂 思路 题目中给出了一些必败态，那么由此可知，每一个必败态（x,y)，那么由此推出的（x + k, y + s * k), (x + s * k, y + k)就一定是必胜态。 由此我们使用dp[x][y[来表示状态, dp[x][y] = 1,
毕设酒店管理系统论文视频源码集.zip
07-27
[毕设]酒店管理系统论文视频源码集" 是一个针对计算机科学或信息技术相关专业学生毕业设计项目的综合资源包。这个资源集包含了酒店管理系统开发所需的各个方面，旨在帮助学生从理论到实践全面理解和掌握酒店管理系统的开发流程和技术细节。 具体来说，这个资源集通常包括： 论文：详细阐述了酒店管理系统的背景、需求分析、系统设计、实现过程及测试验证等各个环节，为学生提供了系统的理论框架和思路指导。 视频教程：通过视频形式，直观地展示了酒店管理系统的开发过程，包括开发环境的搭建、代码编写、数据库设计、功能实现等步骤，便于学生理解和模仿。 源码：提供了酒店管理系统的完整源代码，包括前端界面、后端逻辑及数据库设计等部分，学生可以直接下载并运行，或者根据自己的需求进行修改和扩展。 综上所述，"毕设酒店管理系统论文视频源码集"是一个集论文指导、视频教学和源码实践于一体的综合性资源，对于想要进行酒店管理系统开发的学生来说，具有极高的参考价值和实用性。 参考4条信息源
Qt6.7.2+cmake构建eCAL+protobuf的Demo
07-27
Qt6.7.2+cmake构建eCAL+protobuf的Demo。 1.send Demo 2.rec Demo
pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
ensp模拟器防火墙USG6000V-enspv1.3，设备包
07-27
ensp模拟器防火墙USG6000V-enspv1.3，设备包
基于Java+Springboot的私人西服定制系统源码
最新发布
07-27
开发语言：Java 框架：springboot JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 浏览器：谷歌浏览器
培训课件 -团队的有效激励.pptx
07-27
培训课件 -团队的有效激励.pptx
pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值