HENAU冬令营 搜索专题

A - 棋盘问题

在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。
Input
输入含有多组测试数据。
每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8 , k <= n
当为-1 -1时表示输入结束。
随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域， . 表示空白区域（数据保证不出现多余的空白行或者空白列）。
Output
对于每一组数据，给出一行输出，输出摆放的方案数目C （数据保证C<2^31）。
Sample Input
2 1
#.
.#
4 4
…#
…#.
.#…
#…
-1 -1
Sample Output
2
1

#include<bits/stdc++.h>
using namespace std;

int ans,cnt;//总方案数，已经放入棋盘棋子的个数 
int n,k;
string s[10];//棋盘 
int col[20],row[20];//标记某列，行有无棋子 

void dfs(int u) 
{
	if(cnt==k)//棋子个数达到要求，方案数+1，返回上一层 
	{
		ans++;
		return ;
	}
	if (u>=n)return;//若搜出棋盘，返回 
	for(int j=0;j<n;j++)
		if(!col[j]&&s[u][j]=='#'&&!row[u])
		{
			cnt++;
			col[j]=row[u]=1;
			dfs(u+1);
			col[j]=row[u]=0;
			cnt--;
		}
	dfs(u+1);//u行不放棋子 
}
	
int main()
{
	while(cin>>n>>k)
	{
		if(n==-1&&k==-1)break;
		memset(row,0,sizeof row);//每次将标记初始化 
		memset(col,0,sizeof col);
		for(int i=0;i<n;i++)
		{
			cin>>s[i];
		}
		ans=0;
		dfs(0);	
		cout<<ans<<endl;
	}
		
	return 0;
}

B - Perket

你有 N种配料，每种配料有酸度 S 和苦度 B 。用这些配料做成Perket时，总的酸度为所有配料酸度的乘积，总的苦度是所有配料苦度的和。你至少需要添加一种配料。

为了使口感适中，总的酸度和苦度之差的绝对值应该尽可能小，求这个最小值。

输入
第一行 1 个整数N (1≤N≤10) —— 配料的数量。

接下来 N 行每行 2 个整数 Si和Bi—— 每种配料的酸度和苦度。如果用所有配料来做Perket，总的酸度和苦度都≤1e9。
输出
N 行，每行 1 个整数 —— 所求的最小值。
Sample Input 1
1
3 10
Sample Output 1
7
Sample Input 2
2
3 8
5 8
Sample Output 2
1
Sample Input 3
4
1 7
2 6
3 8
4 9
Sample Output 3
1

#include<bits/stdc++.h>
using namespace std;

int n,x=1,y;
int ans=1e9;
int a[20],b[20],vis[20];

void dfs(int u)
{
	if(u>n)return;	
		
	for(int i=0;i<n;i++)
	{
		if(!vis[i])
		{
			vis[i]=1;
			x*=a[i];
			y+=b[i];
			ans=min(ans,abs(x-y));
			dfs(i+1);
			x/=a[i];
			y-=b[i];
			vis[i]=0;
		}		
	}	
}
int main()
{	
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i]>>b[i];
	}
	dfs(0);
	cout<<ans<<endl;	
	return 0;
}

C - 全排列
给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。 我们假设对于小写字母有 ‘a’ < ‘b’ < … < ‘y’ < ‘z’，而且给定的字符串中的字母已经按照从小到大的顺序排列。
输入格式
输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在 11 到 66 之间。
输出格式
输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排列在前面。字母序如下定义：
已知 S = s_1s_2…s_k, T = t_1t_2…t_kS=s1s2…sk,T=t1t2…tk，则 S < TS<T 等价于，存在 p (1 \le p \le k)p(1≤p≤k)，使得 s_1 = t_1, s_2 = t_2, …, s_{p - 1} = t_{p - 1}, s_p < t_ps1=t1,s2=t2,…,sp−1=tp−1,sp<tp 成立。
Sample Input
abc
Sample Output
abc
acb
bac
bca
cab
cba

#include<bits/stdc++.h>
using namespace std;

int n;
char s[10],a[10];
int vis[10];
void dfs(int u)
{
	if(u==n)
	{
		for(int i=0;i<n;i++)
		cout<<a[i];
		cout<<endl;
	}
	for(int i=0;i<n;i++)
	{
		if(vis[i]==0)
		{
			vis[i]=1;
			a[u]=s[i];
			dfs(u+1);
			vis[i]=0;
		}		
	}		
}
int main()
{
	cin>>s;
	n=strlen(s);
	dfs(0);
	return 0;
}

D - 自然数拆分
对于任意大于 1的自然数 n，总是可以拆分成若干个小于 n 的自然数之和。
现请你编写程序求出 n 的所有拆分。
输入格式
输入文件共一行，包含一个自然数，即要拆分的自然数 n(1≤n≤20)。
输出格式
输出文件有若干行，每行包含一个等式，即代表一种可行的拆分（格式与顺序参见样例）。
Sample Input
5
Sample Output
5=1+1+1+1+1
5=1+1+1+2
5=1+1+3
5=1+2+2
5=1+4
5=2+3

此题视频详解

#include<bits/stdc++.h>
using namespace std;

int f[25];
int n;

void out(int n,int k)
{
	cout<<n<<"=";
	for(int i=1;i<=k-1;i++)
	cout<<f[i]<<"+";
	cout<<f[k]<<endl;
}

void dfs(int dep,int rest)
{
	if(rest==0&&dep>2)
	{
		out(n,dep-1);
		return ;
	}
	else 
	{
		for(int i=1;i<=rest;i++)
		{
			if(i>=f[dep-1])
			{
				f[dep]=i;
			rest-=i;
			dfs(dep+1,rest);
			f[dep]=0;
			rest+=i;
			}	
		}
	}
}
int main()
{
	cin>>n;
	f[0]=1;
	dfs(1,n);
	
	return 0;
}

E - Prime Ring Problem
输入正整数 n，把整数 1,2,…,n 排成一个环，使得相邻两个整数之和均为素数。输出时，从整数 1 开始逆时针排列。同一个环恰好输出一次。n≤16，保证一定有解。
多组数据，读入到EOF结束。
第 i 组数据输出前加上一行Case i:
相邻两组输出中间加上一个空行。
输入样例
6
8
输出样例
Case 1:
1 4 3 2 5 6
1 6 5 2 3 4
Case 2:
1 2 3 8 5 6 7 4
1 2 5 8 3 4 7 6
1 4 7 6 5 8 3 2
1 6 7 4 3 8 5 2
输出格式提示
行末无空格
最后一个Case输出后不换行

#include<bits/stdc++.h>
using namespace std;

int n,ok;
int a[20],vis[20];

int isprime(int x)
{
	for(int i=2;i*i<=x;i++)
	{
		if(x%i==0)return 0;
	}
	return 1;
}
void dfs(int x)
{
	if(x==n&&isprime(a[n-1]+a[0]))
	{
		cout<<a[0];
		for(int i=1;i<n;i++)
		cout<<" "<<a[i];
		cout<<endl;
		return ;
	}	
	for(int i=2;i<=n;i++)
	{
		if(isprime(a[x-1]+i)&&vis[i]==0)
		{
			vis[i]=1;
			a[x]=i;
			dfs(x+1);
			vis[i]=0;
			a[x]=0;
		}
	}	
}

int main()
{	
	int t=0;
	while(cin>>n)
	{
		if(t>=1)cout<<endl;
		memset(vis,0,sizeof vis);
		cout<<"Case "<<++t<<":"<<endl;
		a[0]=1;
		dfs(1);	
	}	
}

F - Red and Black
有一个长方形的房间，覆盖了正方形的磁砖。每块磁砖的颜色，要么是红色，要么是黑色。一名男子站在一块黑色的磁砖上。他可以从一块磁砖移至相邻四块磁砖中的某一块。但是，他不允许在红色磁砖上移动，他只允许在黑色磁砖上移动。

编写一个程序，使得他允许重复上述的移动，判断他所能到达的黑色磁砖的数量。
输入
输入由多个数据集组成。数据集的起始行包含了两个正整数 W 和 H；W 和 H 分别是 x- 和 y- 方向的磁砖数量。W 和 H 不超过 20 。

在数据集中，还有 H 行，每行包含了 W 个字符。每个字符按如下方式表示一块磁砖的颜色。

‘.’ - 一块黑色的磁砖
‘#’ - 一块红色的磁砖
‘@’ - 一名男子，站在一块黑色磁砖上 (在一个数据集中，恰好出现一次)

以包含两个 0 的一行，表示输入结束。
输出
对于每个数据集，程序应当输出一行，包含他从初始磁砖所能抵达的磁砖数量 (包括初始磁砖自身)。
示例输入
6 9
…#.
…#
…
…
…
…
…
#@…#
.#…#.
11 9
.#…
.#.#######.
.#.#…#.
.#.#.###.#.
.#.#…@#.#.
.#.#####.#.
.#…#.
.#########.
…
11 6
…#…#…#…
…#…#…#…
…#…#…###
…#…#…#@.
…#…#…#…
…#…#…#…
7 7
…#.#…
…#.#…
###.###
…@…
###.###
…#.#…
…#.#…
0 0
示例输出
45
59
6
13

#include<bits/stdc++.h>
using namespace std;

const int N=30;
typedef pair<int,int>PII;
queue<PII>q;

char mp[N][N];
int vis[N][N];
int ans,n,m,sx,sy;

int dx[]={1,-1,0,0};
int dy[]={0,0,-1,1};

void bfs(int sx,int sy)
{
	q.push({sx,sy});
	vis[sx][sy]=1;
	
	while(q.size())
	{
		auto t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int a=t.first+dx[i],b=t.second+dy[i];
			if(a>0&&a<=n&&b>0&&b<=m&&!vis[a][b]&&mp[a][b]=='.')
			{
				vis[a][b]=1;
				q.push({a,b});
				ans++;
			}
		} 	
	}			
}

int main()
{
	while(cin>>m>>n)
	{
		memset(vis,0,sizeof vis);
		if(n==0&&m==0)break;
		ans=1;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++)
			{
				cin>>mp[i][j];
				if(mp[i][j]=='@')
				{
					sx=i;
					sy=j;
				}
			}	
		bfs(sx,sy);
		cout<<ans<<endl;
	}
	return 0;
}

G - Knight Moves
编写一个程序，计算一个骑士从棋盘上的一个格子到另一个格子所需的最小步数。骑士一步可以移动到的位置由下图给出。

输入格式
第一行给出骑士的数量 n。
在接下来的 3n 行中，每 3行描述了一个骑士。其中，
• 第一行一个整数 LL 表示棋盘的大小，整个棋盘大小为 L×L；
• 第二行和第三行分别包含一对整数 (x,y)，表示骑士的起始点和终点。假设对于每一个骑士，起始点和终点均合理。
输出格式
对每一个骑士，输出一行一个整数表示需要移动的最小步数。如果起始点和终点相同，则输出 0。
样例
Input
3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1
Output
5
28
0
数据范围与提示
对于 100%100% 的数据，有 4\le L\le 3004≤L≤300，保证 0\le x,y\le L-10≤x,y≤L−1。

#include<bits/stdc++.h>
using namespace std;

const int N=310;
typedef pair<int,int>PII;

queue<PII>q; 

int dx[]={-1,-2,-2,-1,1,2,2,1};
int dy[]={-2,-1,1,2,2,1,-1,-2};

int n,ans;
int sx,sy,tx,ty;
int vis[N][N],dis[N][N];

int bfs(int sx,int sy)
{
	q.push({sx,sy});
	vis[sx][sy]=1;
		
	while(q.size())
	{
		auto t=q.front();
		q.pop();
		
		if(t.first==tx&&t.second==ty)return dis[tx][ty];
		
		for(int i=0;i<8;i++)
		{
			int a=t.first+dx[i],b=t.second+dy[i];
			if(a>=0&&a<n&&b>=0&&b<n&&!vis[a][b])
			{
				vis[a][b]=1;
				q.push({a,b});
				dis[a][b]=dis[t.first][t.second]+1;			
			}			
		}	
	}
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		cin>>n>>sx>>sy>>tx>>ty;
		while(q.size())q.pop();
		memset(vis,0,sizeof(vis));
		memset(dis,0,sizeof(dis));
		ans=bfs(sx,sy);
		
		cout<<ans<<endl;	
	}
	return 0;
}

H - Oil Deposits
某公司负责探测地下油层，每次处理一个大的矩形区域。先创建一个网格，将土地划分为许多方形块，然后用传感设备分别探测每个地块，以确定该地块是否含有石油。一块含有石油的土地叫做pocket。如果两个pocket边相邻或对角相邻，则它们属于同一油层的一部分。你的工作是确定在一个网格有多少不同的油层。
Input
输入包含多组数据。每组数据都以包含m和n的一行开始，m和n是网格中行和列的数量（1 <= m <= 100，1 <= n <= 100），由一个空格分隔。如果m = 0，则表示输入结束。下面是m行，每行有n个字符(不包括行尾字符)。每个字符对应一块土地，要么是“*”，代表没有油，要么是“@”，代表一个pocket。
Output
输出网格有多少不同的油层。

Sample Output
0
1
2
2

#include<bits/stdc++.h>
using namespace std;

const int N=110;
typedef pair<int,int>PII;
queue<PII>q;

int dx[]={-1,-1,-1,0,0,1,1,1};
int dy[]={-1,0,1,-1,1,-1,0,1};

int vis[N][N];
char mp[N][N];
int n,m,cnt;


void bfs(int sx,int sy)
{
	q.push({sx,sy});
	
	vis[sx][sy]=1;
	
	while(q.size())
	{
		auto t=q.front();
		q.pop();
		
		for(int i=0;i<8;i++)
		{
			int a=t.first+dx[i],b=t.second+dy[i];
			if(a>0&&a<=n&&b>0&&b<=m&&!vis[a][b]&&mp[a][b]=='@')
			{
				vis[a][b]=1;
				q.push({a,b});		
			}
		}		
	}
}

int main()
{
	while(cin>>n>>m)	
	{
		getchar();
		if(n==0&&m==0)break;
		for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>mp[i][j];
	memset(vis,0,sizeof vis);
	
	cnt=0;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			if(mp[i][j]=='@'&&vis[i][j]!=1)
			{
				bfs(i,j);
				cnt++;
			}
		}
			cout<<cnt<<endl;
	
	}
	return 0;
}

I - Lake Counting
由于最近的降雨，农夫约翰的农田里形成了不同位置的水塘。农田被表示为一个矩形，它包含了 N x M (1 <= N <= 100; 1 <= M <= 100) 个小方格。每个方格中，要么包含了水 (‘W’)，要么包含了旱地 (’.’)。农夫约翰想要弄清楚，他的农田中形成了多少个水塘。一个水塘是由包含了水的方格连通而成，这里一个方格被视作与周围的全部八个方格相邻。

给出农夫约翰的农田数据图，判断图中有多少个水塘。
输入

• 第一行：两个以空格分隔的整数: N 和 M

• 第 2…N+1 行：每行 M 个字符，表示农夫约翰的农田中的一行。每个字符要么是 ‘W’ 要么是 ‘.’。字符之间没有空格。
  输出

• 第一行：农夫约翰的农田中，水塘的数量。
  示例输入
  
  示例输出
  3
  提示
  输出细节：有 3 个水塘：一个位于左上方，一个位于左下方，还有一个位于右边。

#include<bits/stdc++.h>
using namespace std;

const int N=110;
typedef pair<int,int>PII;
queue<PII>q;

int dx[]={-1,-1,-1,0,0,1,1,1};
int dy[]={-1,0,1,-1,1,-1,0,1};

int vis[N][N];
char mp[N][N];
int n,m,cnt;

void bfs(int sx,int sy)
{
	q.push({sx,sy});
	
	vis[sx][sy]=1;
	
	while(q.size())
	{
		auto t=q.front();
		q.pop();
		
		for(int i=0;i<8;i++)
		{
			int a=t.first+dx[i],b=t.second+dy[i];
			if(a>0&&a<=n&&b>0&&b<=m&&!vis[a][b]&&mp[a][b]=='W')
			{
				vis[a][b]=1;
				q.push({a,b});		
			}
		}		
	}	
}
int main()
{
	cin>>n>>m;
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>mp[i][j];
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			if(mp[i][j]=='W'&&vis[i][j]!=1)
			{
				bfs(i,j);
				cnt++;
			}
		}	
	cout<<cnt;
	return 0;
}

J - 二叉树先序遍历
输入一个整数n（n <= 100000），表示二叉树中节点个数，编号为1~n。约定1号节点为二叉树的根节点。然后输入n行，每行包括两个整数，第i行表示编号为i的节点的左子节点和右子节点的编号。如果某个节点没有左子节点，那么对应输行的第一个整数为0；如果某个节点没有右子节点，那么对应行的第二个整数为0。
先序遍历输出此二叉树每个节点的编号，每行输出一个编号。
先序遍历（DLR），是二叉树遍历的一种，也叫做先根遍历、前序遍历、前序周游，可记做根左右。前序遍历首先访问根节点然后遍历左子树，最后遍历右子树。
Input
第一行：一个整数n 接下来n行，每行有两个整数
Output
输出n行，每行一个整数，表示节点编号。
Sample Input
5
2 5
3 4
0 0
0 0
0 0
Sample Output
1
2
3
4
5

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;

struct P
{
	int l,r;
}tr[N];
void dfs(int x)
{
	if(x==0)
	{
	return ;
	}
	cout<<x<<endl;
	dfs(tr[x].l);
	dfs(tr[x].r);
	
}

int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>tr[i].l>>tr[i].r;
	}
	dfs(1);
	
	return 0;
}

K - 迷宫（一）
一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。
看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。
输入格式
第一行输入两个整数 n 和 m，表示这是一个 n×m 的迷宫。
接下来的输入一个 n 行 m 列的迷宫。其中 ‘S’ 表示蒜头君的位置，’‘表示墙，蒜头君无法通过，’.‘表示路，蒜头君可以通过’.'移动，'T’表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。
输出格式
输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。
数据范围
1≤n,m≤10。
Sample Input
3 4
S**.
….
*T
Sample Output
no
Sample Input 2
3 4
S.
…
***T
Sample Output 2
yes

#include<bits/stdc++.h>
using namespace std;

const int N=30;
typedef pair<int,int>PII;
queue<PII>q;

char mp[N][N];
int vis[N][N];
int ans,n,m,sx,sy,tx,ty;

int dx[]={1,-1,0,0};
int dy[]={0,0,-1,1};


int bfs(int sx,int sy)
{
	q.push({sx,sy});
	vis[sx][sy]=1;	
	while(q.size())
	{
		auto t=q.front();
		q.pop();
		
		if(t.first==tx&&t.second==ty) return 1;
		for(int i=0;i<4;i++)
		{
			int a=t.first+dx[i],b=t.second+dy[i];
			if(a>0&&a<=n&&b>0&&b<=m&&!vis[a][b]&&(mp[a][b]=='.'||mp[a][b]=='T'))
			{
				vis[a][b]=1;
				q.push({a,b});
				ans++;
			}
		} 		
	}
	return 0;			
}

int main()
{
	cin>>n>>m;
	memset(vis,0,sizeof vis);
	ans=1;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			cin>>mp[i][j];
			if(mp[i][j]=='S')
			{
				sx=i;
				sy=j;
			}
			if(mp[i][j]=='T')
			{
				tx=i;
				ty=j;
			}
		}	
	if(bfs(sx,sy))cout<<"yes"<<endl;
	else cout<<"no"<<endl;	
	return 0;
}

L - 马走日
马在中国象棋以日字形规则移动。请编写一段程序，给定n*m大小的棋盘，以及马的初始位置(x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。
Input
第一行为整数T(T < 10)，表示测试数据组数。每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标n,m,x,y。(0<=x<=n-1,0<=y<=m-1, m < 6, n < 6)
Output
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，0为无法遍历一次。
Sample Input
1
5 4 0 0
Sample Output
32

#include<bits/stdc++.h>
using namespace std;

const int N=20;

int dx[]={-1,-2,-2,-1,1,2,2,1};
int dy[]={-2,-1,1,2,2,1,-1,-2};

int vis[N][N];
int n,m,sum,ans;
int sx,sy;

void dfs(int sx,int sy,int cnt)
{
	if(cnt==sum)
	{
		ans++;
		return ;
	}
	
	for(int i=0;i<8;i++)
	{
		int a=sx+dx[i],b=sy+dy[i];
		if(!vis[a][b]&&a>=0&&a<n&&b>=0&&b<m)
		{
			vis[a][b]=1;
			dfs(a,b,cnt+1);
			vis[a][b]=0;
		}
	}		
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		memset(vis,0,sizeof vis);
		cin>>n>>m>>sx>>sy;
		ans=0;
		sum=n*m;
		vis[sx][sy]=1;
		dfs(sx,sy,1);
		cout<<ans<<endl;
	}
	return 0;
}

M - 八皇后问题
努比亚和苏丹没有子女，所以他要从一些有集成资格的继承者中挑选一个出来继承王位。他希望这个继承者足够聪明，所以他准备了一个西洋棋盘，上面的每个格子中均有一个1−99 的数字。他又准备了 8 个皇后棋子。
8皇后的规则就是不能有任何棋子同行或者同列或者同斜线，在满足这个规则的同时，王位继承者还需要让 8个皇后所在的位置的数字的和是最大的。
输入格式
输入一个数字 k (k≤20)，代表棋盘的数量。
接下来有 k 个棋盘，每个棋盘有 64 个数字，分成 8 行 8 列出入，具体可见样例，每一个数字均小于 100。
输出格式
每一个棋盘对应输出最大的数值， 一共输出 k行。
Sample Input
1
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
48 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64
Sample Output
260

#include<bits/stdc++.h>
using namespace std;

const int N=20;

int mp[N][N],col[N],dg[N],udg[N];
int ans,cnt;

void dfs(int u)
{
	if(u==8)
	{
		ans=max(ans,cnt);
	}
	for(int i=0;i<8;i++)
	{
		if(!col[i]&&!dg[i-u+8]&&!udg[i+u])
		{
			col[i]=dg[i-u+8]=udg[i+u]=1;
			cnt+=mp[u][i];
			dfs(u+1);
			col[i]=dg[i-u+8]=udg[i+u]=0;
			cnt-=mp[u][i];
			
		}
	}	
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		for(int i=0;i<8;i++)			
			for(int j=0;j<8;j++)
			cin>>mp[i][j];
		ans=0,cnt=0;
		dfs(0);
		cout<<ans<<endl;
		
	}
	return 0;
}

N - 选数
已知 n个整数 x1,x2,⋯,xn，以及一个整数 k（k<n）。从 n 个整数中任选 k 个整数相加，可分别得到一系列的和。例如当 n=4，k=3，4 个整数分别为 3，7，12，19时，可得全部的组合与它们的和为：
3+7+12=22
3+7+19=29
7+12+19=38
3+12+19=34
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数： 3+7+19=29。
输入格式
输入格式为：n，k（1≤n≤20,k<n）。
x1,x2,⋯,xn（1≤xi≤5000000）。
输出格式
输出格式为：一个整数（满足条件的种数）。
Sample Input
4 3
3 7 12 19
Sample Output
1

#include<bits/stdc++.h>
using namespace std;
int n,k,cnt;
int a[30];
bool isprime(int x)
{
	for(int i=2;i*i<=x;i++)
	{
		if(x%i==0)return 0;
	}
	return 1;
}
void dfs(int s,int y,int sum)
{
	if(y==k)
	{
		if(isprime(sum))
		cnt++;
		return;
	}
	for(int i=s;i<=n;i++)
	{
		dfs(i+1,y+1,sum+a[i]);
	}
	return ;
}
int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
		cin>>a[i];
		dfs(1,0,0);
	cout<<cnt;
	return 0;
}

O - 打开灯泡 Switch the Lamp On
达达是来自异世界的魔女，她在漫无目的地四处漂流的时候，遇到了善良的少女翰翰，从而被收留在地球上。
翰翰的家里有一辆飞行车。
有一天飞行车的电路板突然出现了故障，导致无法启动。
电路板的整体结构是一个R行C列的网格（R,C≤500），如下图所示。

每个格点都是电线的接点，每个格子都包含一个电子元件。
电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。
在旋转之后，它就可以连接另一条对角线的两个接点。
电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。
达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。
她准备通过计算，旋转最少数量的元件，使电源与发动装置通过若干条短缆相连。
不过，电路的规模实在是太大了，达达并不擅长编程，希望你能够帮她解决这个问题。
注意：只能走斜向的线段，水平和竖直线段不能走。
Input
对于每组测试数据，第一行包含正整数R和C，表示电路板的行数和列数。
之后R行，每行C个字符，字符是"/“和”"中的一个，表示标准件的方向。
Output
对于每组测试数据，在单独的一行输出一个正整数，表示所需的缩小旋转次数。
如果无论怎样都不能使得电源和发动机之间连通，输出NO SOLUTION。
Example
样例输入
3 5
\/\
\///
/\\
样例输出
1
Hint
1≤R,C≤500,
1≤T≤5
本题视频讲解

#include<bits/stdc++.h>
using namespace std;

const int N=510;
typedef pair<int,int>PII;

int dx[]={-1,-1,1,1}; int dy[]={-1,1,1,-1};
int ix[]={-1,-1,0,0}; int iy[]={-1,0,0,-1};
char op[]="\\/\\/";

int n,m;
char mp[N][N];
int dis[N][N];

int bfs()
{
	memset(dis,0x3f,sizeof dis);
	deque<PII>q;
	q.push_back({0,0});
	dis[0][0]=0;
	while(q.size())
	{
		auto t=q.front();
		q.pop_front();
		int x=t.first,y=t.second;
		
		for(int i=0;i<4;i++)
		{
			int a=x+dx[i],b=y+dy[i];
			
			if(a>=0&&a<=n&&b>=0&&b<=m)
			{
				int w=0;
				int j=x+ix[i],k=y+iy[i];
				if(mp[j][k]!=op[i])w=1;
				
				if(dis[a][b]>dis[x][y]+w)
				{
					dis[a][b]=dis[x][y]+w;
					if(w)q.push_back({a,b});
					else q.push_front({a,b});
				}
			}
		}
		
	}
	if(dis[n][m]==0x3f3f3f3f)return -1;
	return dis[n][m];
	
}

int main()
{
	

		cin>>n>>m;
		getchar();
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
				cin>>mp[i][j];
			int ans=bfs();
		if(ans==-1)cout<<"NO SOLUTION";
		else
		cout<<ans<<endl;
	
	return 0;
}

标签：sy,专题,冬令营,int,HENAU,vis,sx,dfs,&&
来源： https://blog.csdn.net/weixin_51534513/article/details/122498830