HAU寒假训练第二周

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<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;

int n,m;
char a[25][25];
int ans;
bool used[25][25];
int dx[4]={0,-1,1,0},dy[4]={-1,0,0,1};
int sx,sy;

void dfs(int x,int y)
{
    ans++;
    for(int i=0;i<4;i++)
    {
        int nx=x+dx[i],ny=y+dy[i];
        if(nx>=0&&nx<n&&ny>=0&&ny<m&&a[nx][ny]=='.'&&!used[nx][ny])
        {
            used[nx][ny]=true;
            dfs(nx,ny);
        }
    }
}

int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(a,0,sizeof(a));
        memset(used,0,sizeof(used));
        ans=0;
        if(!m&&!n)
            break;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                cin>>a[i][j];
                if(a[i][j]=='@')
                {
                    sx=i,sy=j;
                }
            }
        }
        dfs(sx,sy);
        printf("%d\n",ans);
    }
    return 0;
}

G - Knight Moves
题目描述
原题来自：POJ 1915

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

Picture 1

输入格式
第一行给出骑士的数量 nn。
在接下来的 3n3n 行中，每 33 行描述了一个骑士。其中，

第一行一个整数 LL 表示棋盘的大小，整个棋盘大小为 L\times LL×L；
第二行和第三行分别包含一对整数 (x,y)(x,y)，表示骑士的起始点和终点。假设对于每一个骑士，起始点和终点均合理。
输出格式
对每一个骑士，输出一行一个整数表示需要移动的最小步数。如果起始点和终点相同，则输出 00。

样例
Input Output
3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1
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;
int n;
#define MAXN 305
char a[MAXN][MAXN];
bool vis[MAXN][MAXN];
int dir[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}};
struct node
{
    int x;
    int y;
    int step;
}q[100005];
void bfs(int sx,int sy,int ex,int ey)//bfs
{
    int head=1,tail=1;
    memset(vis,0,sizeof(vis));
    vis[sx][sy]=1;
    q[tail].x=sx;
    q[tail].y=sy;
    q[tail].step=0;
    tail++;
    while(head<tail)
    {
        int x=q[head].x;
        int y=q[head].y;
        int step=q[head].step;
        if(x==ex&&y==ey)
        {
            printf("%d\n",step);
            break;
        }
        for(int i=0;i<8;i++)//注意有八个方向
        {
            int nx=x+dir[i][0];
            int ny=y+dir[i][1];
            if(nx>=0&&nx<n&&ny>=0&&ny<n&&vis[nx][ny]==0)
            {
                vis[nx][ny]=1;
                q[tail].x=nx;
                q[tail].y=ny;
                q[tail].step=step+1;
                tail++;
            }
        }
        head++;
    }
}
int main()
{
    int t;
    int sx,sy,ex,ey;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
        bfs(sx,sy,ex,ey);
    }
    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 Input
1 1
*
3 5
@@*
@
@@*
1 8
@@***@
5 5
****@
@@@
@**@
@@@@
@@**@
0 0
Sample Output
0
1
2
2

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int n,m;
char map[110][110];//储存输入数据
int vis[8][2]= {{-1,-1},{-1,0},{-1,1},{0,1},{0,-1},{1,1},{1,0},{1,-1}};//分表代表8个方向。
void dfs(int x,int y)
{
    int i;
    map[x][y]='*';//搜索过了设置成*保证不会经过
    for(i=0; i<8; i++)//枚举8种走发
    {
        //计算下一个点的坐标
        int dx=x+vis[i][0];
        int dy=y+vis[i][1];
        if(dx<0||dx>=n||dy<0||dy>=m)//判断是否越界
            continue;
        if(map[dx][dy]=='@')
        {
            dfs(dx,dy);//开始尝试下一个点
        }
    }
}
int main()
{
    int i,j;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
            break;
        for(i=0; i<n; i++)
        {
            scanf("%s",map[i]);
        }
        int sum=0;
        for(i=0; i<n; i++)
        {
            for(j=0; j<m; j++)
            {
                if(map[i][j]=='@')
                {
                    sum++;//数目加一
                    dfs(i,j);
                }
            }
        }
        printf("%d\n",sum);
    }
    return 0;
}

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

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

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

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

• 第一行：农夫约翰的农田中，水塘的数量。
  示例输入
  10 12
  W…WW.
  .WWW…WWW
  …WW…WW.
  …WW.
  …W…
  …W…W…
  .W.W…WW.
  W.W.W…W.
  .W.W…W.
  …W…W.
  示例输出
  3
  提示
  输出细节：

有 3 个水塘：一个位于左上方，一个位于左下方，还有一个位于右边。

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

//深度优先搜索,从x,y这一点向周围八个点搜索
void DFS(vector<vector<char> >& g,int n,int m,int x,int y)
{
	//每次向周围搜索前，先将x,y这点置为'.',可以理解为遍历过就当作是干地，下次不再遍历
	g[x][y] = '.';
	//向周围八个点开始搜索
	for (int  i = -1; i <= 1; i++) //i = -1的意思是，从(x,y)点的最左边开始搜索
	{
		for (int j = -1; j <= 1; j++) //j = -1 的意思是，从(x,y)点的最上边开始搜索
		{
			//先判断是否超过范围，再判断是否是水池‘W’，如果是，则以这一点继续深搜
			if (x + i >= 0 && x + i < n && y + j >= 0 && y + j < m && g[x + i][y + j] == 'W')
				DFS(g, n, m, x + i, y + j);
		}
	}

}

//求水洼数量
int LakeCounting(vector<vector<char> >& g,int n,int m)
{
	int res = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (g[i][j] == 'W')
			{
				DFS(g,n,m,i,j); //这里的DFS调用相当于搜索极大连通图，DFS里面的是小连通图
				++res;          //极大连通图的数量就是水洼的数量
			}
		}
	}
	return res;
}

int main()
{
	int n = 0, m = 0;
	cin >> n >> m;
	vector<vector<char> > g(n);
	//输入
	for (int i = 0; i < n; i++)
	{
		g[i].resize(m);
		for (int j = 0; j < m; j++)
			cin >> g[i][j];
	}
	//输出
	cout << LakeCounting(g,n,m) << endl;
			

	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"iostream"
#include"string"
#include"algorithm"
using namespace std;
struct p{
	int l,r;
}s[100005];
void dfs(int x)
{
	if(x==0)
	{
		return;
	}
	cout<<x<<endl;
	dfs(s[x].l);
	dfs(s[x].r);
}
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>s[i].l>>s[i].r;
	}
	dfs(1);
	return 0;
}

K - 迷宫（一）

一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。

看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。

输入格式
第一行输入两个整数 nn 和 mm，表示这是一个 n \times mn×m 的迷宫。

接下来的输入一个 nn 行 mm 列的迷宫。其中 ‘S’ 表示蒜头君的位置，’*‘表示墙，蒜头君无法通过，’.‘表示路，蒜头君可以通过’.'移动，'T’表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。

输出格式
输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。

数据范围
1 \le n, m \le 101≤n,m≤10。

Sample Input
3 4
S**.
…*.
*T
Sample Output
no
Sample Input 2
3 4
S.
…
***T
Sample Output 2
yes

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct p{
	int l,r;
}s[100005];
void dfs(int x)
{
	if(x==0)
	{
		return;
	}
	cout<<x<<endl;
	dfs(s[x].l);
	dfs(s[x].r);
}
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>s[i].l>>s[i].r;
	}
	dfs(1);
	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=30;
int n,m,x,y;
int u[8][2]={{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2}};
int vis[N][N];
int sum=0;
void searchh(int x,int y,int step)
{
    for(int i=0;i<=7;i++)
    {
        int xx=x+u[i][0];
        int yy=y+u[i][1];
        if(xx>=0&&xx<n&&yy>=0&&yy<m&&(!vis[xx][yy]))
        {
            vis[xx][yy]=1;
            if(step==n*m) sum++;
            else searchh(xx,yy,step+1);
            vis[xx][yy]=0;
        }
    }
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        memset(vis,0,sizeof(vis));
        sum=0;
        cin>>n>>m>>x>>y;
        vis[x][y]=1;
        searchh(x,y,2);
        cout<<sum<<endl;
    }
    return 0;
}

N - 选数

已知 nn 个整数 x_1,x_2,\cdots,x_nx
1
​
,x
2
​
,⋯,x
n
​
，以及一个整数 kk（k<nk<n）。从 nn 个整数中任选 kk 个整数相加，可分别得到一系列的和。例如当 n=4n=4，k=3k=3，44 个整数分别为 33，77，1212，1919 时，可得全部的组合与它们的和为：

3+7+12=223+7+12=22

3+7+19=293+7+19=29

7+12+19=387+12+19=38

3+12+19=343+12+19=34

现在，要求你计算出和为素数共有多少种。

例如上例，只有一种的和为素数：3+7+19=293+7+19=29。

输入格式
输入格式为：nn，kk（1 \le n \le 20,k<n1≤n≤20,k<n）。

x_1,x_2,\cdots,x_nx
1
​
,x
2
​
,⋯,x
n
​
（1 \le x_i \le 50000001≤x
i
​
≤5000000）。

输出格式
输出格式为：一个整数（满足条件的种数）。

Sample Input
4 3
3 7 12 19
Sample Output
1

#include <stdio.h>

int a[21],n,r;

void dfs(int pos,int num)

{

    if (pos==r)   // 已有r个数

    {

       for (int i=0;i<r;i++)

          printf("%3d",a[i]);

       printf("\n");

       return;

    }

    if(r-pos>n-num+1) return ;

    for(int i=num;i<=n;i++)

    {

        a[pos]=i;

        dfs(pos+1,i+1);

    }

}

int main()

{

    scanf("%d%d",&n,&r);

    dfs(0,1);

    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<cstdio>
#include<algorithm>
#include<cstring>
#include<deque>

#define P pair<int,int>
#define x first
#define y second
#define inf 0x3f3f3f3f

using namespace std;

const int N=510;

int n,m,T;
char g[N][N];
bool st[N][N];
int d[N][N];

int bfs()
{
    memset(st,false,sizeof st);
    memset(d,0x3f,sizeof d);
    d[0][0]=0;
    
    deque<P> dq;
    dq.push_back({0,0});
    
    char op[]="\\/\\/";
    int dir[4][2]={{-1,-1},{-1,1},{1,1},{1,-1}};
    int tdir[4][2]={{-1,-1},{-1,0},{0,0},{0,-1}};
    
    while(dq.size())
    {
        P t=dq.front();
        dq.pop_front();
        
        if(st[t.x][t.y]) continue;
        st[t.x][t.y]=true;
        
        for(int i=0;i<4;i++)
        {
            int x=t.x+dir[i][0],y=t.y+dir[i][1];
            if(x<0||x>n||y<0||y>m) continue;
            
            int gx=t.x+tdir[i][0],gy=t.y+tdir[i][1];
            int dis=d[t.x][t.y]+(g[gx][gy]!=op[i]);
            if(dis<d[x][y])
            {
                d[x][y]=dis;
                
                if(g[gx][gy]!=op[i]) dq.push_back({x,y});
                else dq.push_front({x,y});
            }
        }
    }
    return d[n][m];
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++) scanf("%s",&g[i]);
        
        int res=bfs();
        
        if(res==inf) puts("NO SOLUTION");
        else printf("%d\n",res);
    }
}