必做题Week7

迷宫寻路

题目描述

机器猫被困在一个矩形迷宫里。

迷宫可以视为一个 $n\times m$ 矩阵，每个位置要么是空地，要么是墙。机器猫只能从一个空地走到其上、下、左、右的空地。

机器猫初始时位于 $(1,1)$ 的位置，问能否走到 $(n,m)$ 位置。

输入格式

第一行，两个正整数 $n,m$。

接下来 $n$ 行，输入这个迷宫。每行输入一个长为 $m$ 的字符串，# 表示墙，. 表示空地。

输出格式

仅一行，一个字符串。如果机器猫能走到 $(n,m)$，则输出 Yes；否则输出 No。

样例 #1

样例输入 #1

3 5
.##.#
.#...
...#.

样例输出 #1

Yes

提示

样例解释

路线如下：$(1,1)\to (2,1)\to (3,1)\to (3,2)\to (3,3)\to (2,3)\to (2,4)\to (2,5)\to (3,5)$

数据规模与约定

对于 $100\%$ 的数据，保证 $1\le n,m\le 100$，且 $(1,1)$ 和 $(n,m)$ 均为空地。

思路：这题其实我迷宫寻路也是一道比较模板的dfs的题，就是dfs的那个思路，但是注意这道题不需要回溯，如果回溯你会喜提10分别问我怎么知道的，而为什么不用回溯是由于他只需要知道能不能到(n, m) 这个点而不关心你这个路线到底是怎么样的，那么我们就可以选择不回溯，使程序少重复遍历一些没用的点(个人理解，如果有更好的理解方式，可以在评论区讨论讨论)（其实迷宫问题都可以不用回溯，如果只是说能不能到某一点）

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 110;
int a[N][N];
int flag, n, m;

int mx[4] = {0, 1, 0, -1};
int my[4] = {1, 0, -1, 0};

void dfs(int x, int y)
{
	if(x == n && y == m)
	{
		flag = 1;
		return;
	}
	
	for(int i = 0; i < 4; i++)
	{
		int x1 = x + mx[i], y1 = y + my[i];
		if(!a[x1][y1] && x1 <= n && x1 >= 1 && y1 <= m && y1 >=1)
		{
			a[x1][y1] = 1;
			dfs(x1, y1);
			//a[x1][y1] = 0;
		}
	}
	
}
int main()
{
	char c;
	cin >> n >> m;

	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= m; j++)
		{
			cin >> c;
			if(c == '.')a[i][j] = 0;
			else a[i][j] = 1;
		}
	}
	
	dfs(1, 1);
	
	if(flag)cout << "Yes";
	else cout << "No";
	
	return 0;
}

全排列问题

题目描述

按照字典序输出自然数 $1$ 到 $n$ 所有不重复的排列，即 $n$ 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入格式

一个整数 $n$。

输出格式

由 $1\sim n$ 组成的所有不重复的数字序列，每行一个序列。

每个数字保留 $5$ 个场宽。

样例 #1

样例输入 #1

3

样例输出 #1

1    2    3
    1    3    2
    2    1    3
    2    3    1
    3    1    2
    3    2    1

提示

$1\le n\le 9$。

思路：一道dfs模板题

代码

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

const int N = 10;
int a[N], n;
bool st[N];

void dfs(int u)
{
	if(u == n)
	{
		for(int i = 0; i < n; i++)
		{
			printf("%5d", a[i]);
		}
		printf("\n");
		return;
	}
	
	for(int i = 1; i <= n; i++)
	{
		if(!st[i])
		{
			a[u] = i;
			st[i] = true;
			dfs(u+1);
			st[i] = false;	
		}
		
	}
}
int main()
{
	cin >> n;
	dfs(0);
	
	return 0;
}

求细胞数量

题目描述

一矩形阵列由数字 $0$ 到 $9$ 组成，数字 $1$ 到 $9$ 代表细胞，细胞的定义为沿细胞数字上下左右若还是细胞数字则为同一细胞，求给定矩形阵列的细胞个数。

输入格式

第一行两个整数代表矩阵大小 $n$ 和 $m$。

接下来 $n$ 行，每行一个长度为 $m$ 的只含字符 0 到 9 的字符串，代表这个 $n\times m$ 的矩阵。

输出格式

一行一个整数代表细胞个数。

样例 #1

样例输入 #1

4 10
0234500067
1034560500
2045600671
0000000089

样例输出 #1

4

提示

数据规模与约定

对于 $100\%$ 的数据，保证 $1\le n,m\le 100$。

思路：明显是连通块，于是就可以用dfs进行查找，然后一次完整的dfs算一个连通块，注意这有个比较坑的点是2数据输入的时候要限定每次读入数据的宽度，不然按样例的那个数据一套读下来就只读了四个错误的数

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 110;
int q[N][N], nx[4] = {0, 1, 0, -1}, ny[4] = {1, 0, -1, 0};
bool used[N][N];
int n, m, sum;

void dfs(int x, int y)
{
	used[x][y] = true;
	for(int i = 0; i < 4; i++)
	{
		int mx = x + nx[i];
		int my = y + ny[i];
		if(q[mx][my] == 0 || used[mx][my])continue;
		dfs(mx, my);
	}
}
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= m; j++)
		{
			scanf("%1d", &q[i][j]);//%1d指定了一个宽度，意味着scanf将只读取一个字符宽度的输入作为数字，如输入123则变量中的值将会是1,而2和3则会保留在输入缓存区等待后续被读取
		}
	}
	
	
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= m; j++)
		{
			if(!used[i][j] && q[i][j] != 0)
			{
				dfs(i, j);
				sum++;
			}		
		}
	}
	
	cout << sum;
	return 0;
} 

[USACO1.5] 八皇后 Checker Challenge

题目描述

一个如下的 $6\times 6$ 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。

上面的布局可以用序列 $246135$ 来描述，第 $i$ 个数字表示在第 $i$ 行的相应位置有一个棋子，如下：

行号 $123456$

列号 $246135$

这只是棋子放置的一个解。请编一个程序找出所有棋子放置的解。
并把它们以上面的序列方法输出，解按字典顺序排列。
请输出前 $3$ 个解。最后一行是解的总个数。

输入格式

一行一个正整数 $n$，表示棋盘是 $n\times n$ 大小的。

输出格式

前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。

样例 #1

样例输入 #1

6

样例输出 #1

2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4

提示

【数据范围】
对于 $100\%$ 的数据，$6\le n\le 13$。

题目翻译来自NOCOW。

USACO Training Section 1.5

思路：本题还是找排序的状态，题目说按照行顺序输出，那么遍历就从行这个状态入手，注意有n行的话这个棋盘的主对角线和副对角线的个数不是n个，而应该是2n-1个，不要搞错了，弄得我后面debug了半天

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 30;
int  h[N];
bool dg[N], udg[N], st[N];
int n, c;

void dfs(int u)
{
	if(u == n)
	{
		c++;
		if(c <= 3)
		{
			for(int i = 0; i < n; i++)
			{
				printf("%d ", h[i]);
			}
			cout << endl;
			return;
		}
		else return;
	}
	
	for(int i = 1; i <= n; i++)
	{
		if(!dg[i + u] && !udg[n - i + u] && !st[i])
		{
			h[u] = i;
			dg[u + i] = udg[n - i + u] = st[i] = true;
			dfs(u + 1);
			dg[u + i] = udg[n - i + u] = st[i] = false;
		}
	}
}
int main()
{
	cin >> n;
	
	dfs(0);
	
	cout << c;
	
	return 0;
}