【算法学习】搜索算法（方向数组、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;
}

运行结果