2021-2022年度第三届全国大学生算法设计与编程挑战赛（夏季赛）

2021-2022年度第三届全国大学生算法设计与编程挑战赛（夏季赛）

主要是用于记录涉及的知识点，本次比赛是团队赛。

http://oj.saikr.com/contest/20/problems

部分题目讲解视频：

https://edu.saikr.com/course/957/task/5879/show

B、Path

问题：

地上存在着一个 n \times nn×n 的地图，地图中包括两种字符，PP 和 NN, 其中 PP 表示该处可以通过，NN 表示该处不可以通过。

游戏规定：Makik 需要进行多次滑动。每次滑动选择一个 P 作为自己的起点，从起点出发，并沿着一个方向（上下左右）前进，前进的同时需要保证

1. 不能走到 NN 的格子上
2. 不能走出 n \times nn×n 的地图
3. 不能中途改变方向。

当一次滑动结束时，Makik 可以开始选择下一个 P 并开始下一次滑动直到地图中不存在 PP, 游戏结束。

为了增加游戏的趣味性，每经过一个格子，这个格子就会从 PP 变成 NN。

米忽悠为了让游戏充满挑战性，进行的滑动的次数越少，得到的奖励越多，现在 Makik 想要拿到最高等级的奖励，来抽取小吉祥草王，所以他把地图交给了你，请你好好研究下怎么解决这个问题。

Input

第一行一个数字 nn 表示正方形地图的边长

接下来 nn 行，每行 1 个长度为 nn 的字符串，由 NN 和 PP 组成。

Output

一行一个数字，表示最少需要的滑动次数。

Sample Input 1

2
PN
NP
1
2
3

Sample Output 1

2
1

Sample Input 2

5
PNNPN
PNPPP
NPPPP
PNNNP
PNNNP
1
2
3
4
5
6

Sample Output 2

6
1

Hint 数据规模

n≤50

解题思路：

属于网络流问题，问题在于怎么防止在某个点转向

将横纵拆开，设立源点S，汇点T。

C、Square

枚举分割线，DP即可

相同的题:

https://codeforces.com/contest/1404/problem/E

D、Poly

也涉及了枚举

F、String

问题：

Makik 在上次的比赛后沉迷原神，现在要向你展示他给史莱姆排队的能力。

具体而言，我们用一个大写字母来表示一种史莱姆，同种史莱姆之间没有区别，这里我们认为共有 26 种不同类型的史莱姆。

Makik 有一个已经排好队的史莱姆序列 B， 现在又给了你一个还没排好队的史莱姆序列 A， 请问最少多少次操作能把 A 排成 B呢？

这个问题太简单了，所以 Makik 加了个限制条件：

每次移动 A 中的史莱姆的时候，只能将想要移动的史莱姆从原来的位置移动到队头，也就是第一个史莱姆的前面。

请问在这个限制下，最少多少次操作可以将 A 排成 B 呢？

Input

第一行一个数字 nn， 表示史莱姆序列的长度。

接下来一行 nn 个大写字母组成的字符串，表示史莱姆序列 A。

再接下来一行 nn 个大些字母组成的字符串，表示史莱姆序列 B。

Output

一行一个数字，表示最少需要的操作次数。

Sample Input 1

10
SIAJOIWUGB
IBUSJGWAOI
1
2
3

Sample Output 1

7
1

Hint

1≤n≤10**6 , 数据保证至少存在一种方法将 AA 排成 BB。

解题思路：

以B的最后一个字符倒序开始找连续的字符串在A中相同出现顺序的最长长度，一定要以B的最后一个字符开始。

#include <iostream>
using namespace std;
char a[1000005];
char b[1000005];
int n;
int main()
{
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> a[i];
	}
	for(int i=0;i<n;i++){
		cin >> b[i];
	}
	int ar,br=n-1;
	int bl;
	int min0=n;
	int count=0;
	bl=br;
	ar=n;
	while(ar>=0){
		if (b[bl]==a[ar]){
			bl--; 
			count++;
		}
		ar--;
		if (bl<0){
			break;
		}
	}	
	cout << n-count << endl;
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

G、Rev

循环卷积，给定卷积后的结果，求符合条件的对称序列

I、Tree

有多少种本质不同的树上递增路径

度数写到节点上，不妨看为由度数作为一个广义字符的后缀树

问题转化为求本质不同的子串

后缀自动机

J、大富翁

问题：

机会卡描述如下:你会来到一个给定的街道，街道上一共有无限个店家相连，因此可以把街道看作是一个一维的数列，街道的前n个店有一个数值a_ia**i，表示你可以选择走到后面的0-a_i0−a**i个店，比如你当前在1号店，店的数值为3，则你选择可以走到1,2,3,4号店，越到后面的店的奖励越好，所以你想知道这样最远能走到哪一家店。

Input

第一行一个整数nn，表示有n家店（1 \leq n \leq 100000）（1≤n≤100000）第二行n个整数，表示每个店的数值a_ia**i(0 \leq a_i \leq 100000)(0≤a**i≤100000)

Output

一个整数x,表示能走到的最远的店

Sample Input 1

5
1 1 1 1 1
1
2

Sample Output 1

6
1

解题思路：

虽然这题没做完，但是有一定的想法。

从后往前将每个位置的值和最后一个位置的位置进行差分后排序，就知道哪个是走出最后一个有值的位置最远的点，然后看能不能从起点到达这个max的位置，如果不行就换成次的，直到找到能抵达的点。至于怎么看能不能从起点到这个点，也是倒着推的思想，先将max前的点的值与max的位置进行差分，选择差分在正的范围中里max最远的点，再以这个新点开始重复刚才的操作直到能不能到起点。但是这个做法似乎不是很靠谱。

#include <iostream>
#include <algorithm> 
using namespace std;

struct tmp1
{
	int pos;
	int ai;
}aa[100002];

struct tmp2
{
	int pos;
	//用来记倒叙的位置 
	int pos_n;
	//用来记录与最后一个店的差值
	int bi;
}bb[100002];

int cmp(const tmp &, const tmp &);

//定义排序规则
int cmp(const tmp &s1, const tmp &s2)
{
	//从大到小排序 
	return s1.bi > s2.bi;
} 

int n;

int main()
{
	cin >> n;
	for (int i=0;i<n;i++){
		aa[0].pos=i;
		bb[0].pos=i;
		bb[0].pos_n=n-1-i;
		cin >> aa[0].ai;
		bb[0].bi=aa[0].ai-bb[0].pos_n;
	}
	//按照差值降序
	sort(bb,bb+n,cmp);
//	for (int i=0;i<n;i++){
//		cout << aa[i].bi << endl;
//	}
	int m=0;
	while(m<n){
		int max_pos=bb[m].pos;
		for (int i=0;i<n;i++){
			//没写完
		}
		m++;
	}
	
	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59