搜索算法(方向数组、dfs搜索)
1.方向数组的搜索(欧拉11题)
题目描述
方阵中的最大乘积
在如下的20×20方阵中,有四个呈对角线排列的数被加粗了。
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
这四个数的乘积是26 × 63 × 78 × 14 = 1788696。
在这个20×20方阵中,四个在同一方向(从下至上、从上至下、从右至左、从左至右或者对角线)上相邻的数的乘积最大是多少?
题目分析
我们引入方向数组的概念,定义dir[k][n]
k表示方向的个数,n表示每个方向的维度,每个向量表示某个方向的偏移量
为了更好的与数组进行结合,我们选择竖直向下为x方向,水平向右为y轴方向
对于这个题目来说,我们一共有8个方向,即A-H
假设中心点为(x,y)则A-H分别为(x-1,y-1),(x-1,y),(x-1,y+1),(x,y+1),(x+1,y+1),(x+1,y+0),(x+1,y-1),(x,y-1)
所以我们取的dir[8][2]={{-1,-1},{-1,0},{-1,+1},{0,+1},{+1,+1},{+1,0},{+1,-1},{0,-1}}
我们遍历所有的点,每个点按照方向向量的8个方向取另外的三个点得到4点的乘积,不断更新最大的乘积即可,边界条件要注意当我们取点取到边界外时停止取点,因为上述ABCD与EFGH方向对称,遍历其他点的ABCD方向就可以得到另外点的EFGH方向,所以我们只需保留4个方向即可,即dir[4][2]={{-1,-1},{-1,0},{-1,+1},{0,+1}}
题目代码
#include<stdio.h>
#define max_n 20
int arr[max_n + 5][max_n + 5];
int dir[4][2]={{-1, -1}, {-1, 0}, {-1, +1}, {0, +1}};
int calc(int x, int y){//返回(x,y)四个方向连续四个数乘积的最大值
int ans = 0;
for(int k = 0; k < 4; k++){
int p = 1;//每一个方向结束后,都得将中间量p置1
for(int step = 0; step < 4; step++){
int dx = x + dir[k][0] * step;
int dy = y + dir[k][1] * step;
if(dx < 0 || dx >= max_n || dy < 0 || dy >= max_n) break;//如果越界则跳出循环
p *= arr[dx][dy];
}
if(p > ans) ans = p;
}
return ans;
}
int main(){
int ans = 0;
for(int i = 0; i < max_n; i++){
for(int j = 0; j < max_n; j++){
scanf("%d", &arr[i][j]);
}
}//读入数据
for(int i = 0; i < max_n; i++){
for(int j = 0; j < max_n; j++){
int p = calc(i, j);
if(p > ans) ans = p;
}
}
printf("%d\n", ans);
return 0;
}
运行效果
2.DFS搜索算法(深度优先搜索)
首先给出参考博客地址
https://blog.csdn.net/ldx19980108/article/details/76324307#commentBox
基本概念
深度优先搜索算法(Depth First Search,简称DFS):一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件,搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。
算法思想
回溯法(探索与回溯法)是一种选优搜索法,又称为试探法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。
题目1描述
马在中国象棋以日字形规则移动。
请编写一段程序,给定 n×m大小的棋盘,以及马的初始位置 (x,y),要求不能重复经过棋盘上的同一个点,计算马可以有多少途径遍历棋盘上的所有点。(m,n<=11)
题目1分析
o为当前点,则定义一个方向向量组
dir[8][2]={
{-2, 1}, {-2, -1}, {2, -1}, {2, 1},
{-1, -2}, {-1, 2}, {1, -2}, {1, 2}
};
我们定义一个变量cnt,当马走过一个点时,cnt+1,则当cnt = m * n时,即找到一个答案,当我们走过某个点时,为避免重复,我们应将当前点标记为1,只有下个点为0时才说明下个点没走过,当我们找到一条路径时,我们要将cnt初始化,将所有点的标记也要去掉,为了寻找下个路径。
下面为使用dfs搜索算法的具体流程:
1.判断边界条件:
这里我们有3个边界条件
a)当x,y超出棋盘范围时
b)当当前点被标记过时(即已经走过时)
c)当我们找到一条路径时,即cnt = m * n
2.当不是边界时,我们尝试每一种可能,记住每走一点我们要将这个点标记为1,并将cnt+1
3.当我们回溯时要记得将标记过的点清0
题目1代码
#include<stdio.h>
#include<string.h>
#define max_n 10
int arr[max_n + 5][max_n + 5];
int dir[8][2]={
{-2, 1}, {-2, -1}, {2, -1}, {2, 1},
{-1, -2}, {-1, 2}, {1, -2}, {1, 2}
};
int ans = 0;
int n, m, sx, sy;
void dfs(int x, int y, int cnt){
if(x < 0 || x >= n || y < 0 || y >= m) return ;
if(arr[x][y]) return ;
if(cnt == m * n) {
ans += 1;
return ;
}
arr[x][y] = 1;
for(int k = 0; k < 8; k++){
int dx = x + dir[k][0];
int dy = y + dir[k][1];
dfs(dx, dy, cnt + 1);
}
arr[x][y] = 0;
}
int main(){
int cnt = 1;
memset(arr, 0, sizeof(arr));//清空arr
scanf("%d%d%d%d", &n, &m, &sx, &sy);
dfs(sx, sy, cnt);
printf("%d\n", ans);
return 0;
}
运行结果
题目2描述
在一个给定形状的棋盘(形状可能是不规则的)上面摆放棋子,棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列,请编程求解对于给定形状和大小的棋盘,摆放k个棋子的所有可行的摆放方案C。
input: 输入含有多组测试数据。 每组数据的第一行是两个正整数,n k,用一个空格隔开,表示了将在一个n*n的矩阵内描述棋盘,以及摆放棋子的数目。 n <= 8 , k <= n 当为-1 -1时表示输入结束。 随后的n行描述了棋盘的形状:每行有n个字符,其中 # 表示棋盘区域, . 表示空白区域(数据保证不出现多余的空白行或者空白列)。
output:对于每一组数据,给出一行输出,输出摆放的方案数目C (数据保证C<2^31)。
题目2分析
定义一个arr[10][10]当作棋盘,存放./#,定义一个col[10]用来标记某一列是否放了棋子,当找到一种途径回溯时,记得将这一列的标记清0,便于寻找下一种可能的途径。k用来表示还剩多少棋子,每当找到一个合适的位置,k-1,当k=0时表示找到了一种可能。
用dfs搜索算法:
1.出口:当k=0时,找到了一个可行解,ans+=1;
2.我们从当前放置棋子的下一行遍历,内层嵌套对每一列的遍历,我们要判断这一列的标记是否为1,也要判断当前位置arr[i][j]是否为.,这两种情况直接continue,进行下一列的判断,如果当前列符合情况,则我们要将当前列的标记col[j]置为1,在进行深度搜索,即开始遍历下一行,遍历列,等待回溯,注意再次进行深度搜索时k要-1。
3.回溯过程要将列的标记位清0。
题目2代码
#include<stdio.h>
#include<string.h>
int ans = 0;
char arr[10][10];
int col[10];
int n;
void dfs(int r, int k){
if(k == 0){
ans++;
return ;
}
for(int i = r; i < n; i++){
for(int j = 0; j < n; j++){
if(col[j] || arr[i][j] == '.') continue;
col[j] = 1;
//k--;//不能在这里--,遍历每一列时都会减1,使棋子数量变少
dfs(i + 1, k - 1);
col[j] = 0;//要在这里清0,遍历完这一列的所有可行解后,开始遍历下一列可行解,这一列的标记位清0
}
//col[j] = 0;
}
}
int main(){
while(1){
int k;
scanf("%d%d", &n, &k);
getchar();
memset(arr, '\0', sizeof(arr));
memset(col, 0, sizeof(col));
ans = 0;
if(n == -1 && k == -1) break;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
scanf("%c", &arr[i][j]);
}
getchar();
}
dfs(0, k);
printf("%d\n", ans);
}
return 0;
}
运行结果