算法：dfs（深度优先搜索）经典例题

又食又拎广东亲戚

已于 2024-04-05 16:05:46 修改

阅读量633

点赞数 4

文章标签：算法深度优先 java c语言 dfs

于 2024-03-24 16:33:58 首次发布

本文链接：https://blog.youkuaiyun.com/2301_79526467/article/details/136921499

版权

1. 九宫格 (c实现）

// dfs习题：
// 输入9行，0代表未知
// 输出9行即最终结果
#include <stdio.h>
#include <stdlib.h>
int main() {
	int table[9][9];
	//输入数据
	for (int i = 0; i < 9; i++) {
		for (int j = 0; j < 9; j++) {
			scanf("%d", &table[i][j]);
		}
	}

	dfs(table, 0, 0);
	
	return 0;
}

void dfs(int table[9][9], int x, int y)
{
	if (x == 9)
	{
		//打印最终数组数据
		my_print(table);
		exit(0);
	}
	// '0'要填入数字
	if (table[x][y] == 0)
	{
		//循环遍历要填入什么数字
		for (int k = 1; k <= 9; k++)
		{
			//检查行，列，九宫格是否含有该数字
			if (check(table, x, y, k) == 1)
			{
				table[x][y] = k;
				dfs(table, x + (y + 1) / 9, (y + 1) % 9);
			}
		}
		//回溯
		table[x][y] = 0;
	}
	else
	{
		//不是0则遍历下一个位置
		dfs(table, x + (y + 1) / 9, (y + 1) % 9);
	}
}

int check(int table[9][9], int x, int y, int k)
{
	//检查行、列是否含有数字k
	for (int i = 0; i < 10; i++) {
		if (table[i][y] == k || table[x][i] == k) {
			return -1;
		}
	}
	//检查九宫格是否含有数字k
	//x / 9定位所处行，y / 9定位所处列
	x /= 9;
	y /= 9;
	//定位到所处行、列坐标后遍历九宫格
	for (int i = 3 * x; i < 3 * x + 3; i++) {
		for (int j = 3 * y; j < 3 * y + 3; j++) {
			if (table[i][j] == k) {
				return -1;
			}
		}
	}
	//当行、列、九宫格内均不包含该数字返回1
	return 1;
}

//打印最终九宫格内容
void my_print(int table[9][9]) {
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			printf("%d ", table[i][j]);
		}
		printf("\n");
	}
}

2. 全排列不含重复数字（Java实现）

描述

给出一组数字，返回该组数字的所有排列

例如：

[1,2,3]的所有排列如下
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1].
（以数字在数组中的位置靠前为优先级，按字典序排列输出。）

数据范围：数字个数 0<�≤60<n≤6

要求：空间复杂度 �(�!)O(n!) ，时间复杂度 �(�!）O(n!）

示例1

输入：
[1,2,3]
复制返回值：
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

迭代实现

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param num int整型一维数组 
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> permute (int[] num) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        ArrayList<Integer> empty = new ArrayList<>();
        res.add(empty);
        
        for (int i = 0; i < num.length; i++) {
            //所有新排序集合存储再该集合temres中
            ArrayList<ArrayList<Integer>> temres = new ArrayList<>();
            //循环遍历当前集合的所有排序集合
            for (ArrayList<Integer> r : res) {
                //每个排序集合中从头到尾依次插入一个新数字形成新集合
                for (int j = 0; j < r.size() + 1; j++) {
                    //新排序集合
                    ArrayList<Integer> tem = new ArrayList<>(r);
                    tem.add(j, num[i]);
                    temres.add(tem);
                }
            }
            //所有新排序集合直接覆盖原集合
            res = temres;
        }
        return res;
    }
}

3. 全排列含重复数字（Java实现）

递归实现

描述

给出一组可能包含重复项的数字，返回该组数字的所有排列。结果以字典序升序排列。

数据范围： 0<�≤80<n≤8 ，数组中的值满足 −1≤��≤5−1≤val≤5

要求：空间复杂度 �(�!)O(n!)，时间复杂度 �(�!)O(n!)

示例1

输入：
[1,1,2]
返回值：
[[1,1,2],[1,2,1],[2,1,1]]

递归实现

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param num int整型一维数组 
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> permuteUnique (int[] num) {
        // write code here
        //存储所有排序集合
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        //存储单个排序集合
        ArrayList<Integer> tem = new ArrayList<>();
        //判断是否存入集合
        boolean[] flag = new boolean[num.length];
        Arrays.fill(flag, false);
        
        Arrays.sort(num);
        returnres(res, tem, num, flag);
        return res;
    }
    public void returnres(ArrayList<ArrayList<Integer>> res, ArrayList<Integer> tem, int[] num, boolean[] flag) {
        //当排序集合的元素等于数组的元素个数时完成一次排序，可直接返回
        if (tem.size() == num.length) {
            //将该排列顺序添加至总排序集合中
            res.add(new ArrayList<Integer>(tem));
            return;
        }
        //依次将数组的每一个元素添加到集合中
        for (int i = 0; i < num.length; i++) {
            //判断该元素是否已经再集合中
            if (flag[i]) {
                continue;
            }
            //排列的集合顺序要不重复，筛选元素
            if (i > 0 && num[i] == num[i - 1] && !flag[i - 1]) {
                continue;
            }
            tem.add(num[i]);
            flag[i] = true;
            returnres(res, tem, num, flag);
            //回溯
            flag[i] = false;
            tem.remove(tem.size() - 1);
        }
    }
}

4. 岛屿数量（c实现）

描述

给一个01矩阵，1代表是陆地，0代表海洋，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。

岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右）判断岛屿个数。

例如：

输入

[

[1,1,0,0,0],

[0,1,0,1,1],

[0,0,0,1,1],

[0,0,0,0,0],

[0,0,1,1,1]

]

对应的输出为3

(注：存储的01数据其实是字符'0','1')

示例1

输入：
[[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]]
返回值：
3

/**
 * 判断岛屿数量
 * @param grid char字符型二维数组
 * @param gridRowLen int grid数组行数
 * @param gridColLen int* grid数组列数
 * @return int整型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
//注意里面的数字是字符。
int rowpath[] = {-1, 0, 1, 0};
int colpath[] = {0, -1, 0, 1};
void dfs(char** grid, int gridRowLen, int* gridColLen, int row, int col) {
    if(row<0||col<0||row==gridRowLen||col==*gridColLen||grid[row][col]=='0')return ;
    grid[row][col] = '0';
    for (int i = 0; i < 4; i++) {
        dfs(grid, gridRowLen, gridColLen, row + rowpath[i], col + colpath[i]);
    }
}

int solve(char** grid, int gridRowLen, int* gridColLen) {
    // write code here
    int count = 0;
    for (int i = 0; i < gridRowLen; i++) {
        for (int j = 0; j < *gridColLen; j++) {
            if (grid[i][j] == '1') {
                dfs(grid, gridRowLen, gridColLen, i, j);
                count++;
            }
        }
    }
    return count;
}

5. 字符串排序（c实现）

描述

输入一个长度为 n 字符串，打印出该字符串中字符的所有排列，你可以以任意顺序返回这个字符串数组。

例如输入字符串ABC,则输出由字符A,B,C所能排列出来的所有字符串ABC,ACB,BAC,BCA,CBA和CAB。

数据范围：�<10n<10
要求：空间复杂度 �(�!)O(n!)，时间复杂度 �(�!)O(n!)

输入描述：

输入一个字符串,长度不超过10,字符只包括大小写字母。

示例1

输入：
"ab"
返回值：
["ab","ba"]
说明：
返回["ba","ab"]也是正确的         

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param str string字符串 
 * @return string字符串一维数组
 * @return int* returnSize 返回数组行数
 */
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
int compare (const void * a, const void * b)
{
  return ( *(char*)a - *(char*)b );
}
/**
参数列表：
    res：返回的结果集合
    str：原串
    returnSize：结果集合的长度
    tem：排序的字符串
    temlen：排序的字符串当前的长度
    flag：判断遍历到的当前元素是否加入排序串中
*/
void dfs(char* res[], char* str, int* returnSize, char tem[], int temlen, int flag[]) {
    //当前排序的元素和字符串一样长直接返回
    if (strlen(str) == temlen) {
        //开辟新空间存储该字符串
        char* new = (char*)malloc(sizeof(char) * temlen);
        for (int i = 0; i < temlen; i++) {
            new[i] = tem[i];
        }
        res[(*returnSize)++] = new;
        temlen = 0;
        return;
    }
    //递归筛选所有排列顺序
    for (int i = 0; i < strlen(str); i++) {
        //当前元素已添加到排列集合，跳过
        if (flag[i]) {
            continue;
        }
        //筛选排列顺序，避免重复
        if (i > 0 && str[i] == str[i - 1] && !flag[i - 1]) {
            continue;
        }
        tem[temlen++] = str[i];
        flag[i] = 1;
        dfs(res, str, returnSize, tem, temlen, flag);
        //不满足条件回溯
        flag[i] = 0;
        temlen--;
    }
}

char** Permutation(char* str, int* returnSize ) {
    // write code here
    if (str == NULL) {
        *returnSize = 0;  
        return NULL;
    }
    
    //字符串长度len
    int len = strlen(str);
    //最多可能出现size种排序情况
    int size = 1;
    for (int i = 1; i <= len; i++) {
        size *= i;
    }
    //flag数组判断字符串中的字符是否已经添加到排序集合中 0：否 1：是
    int flag[len];
    memset(flag, 0, 4 * len);
    //开辟数组长度为size的空间存储所有排序情况
    char** res = (char**)malloc(sizeof(char*) * size);
    //临时存储排序情况的数组
    char tem[len];
    //字符串排序
    qsort(str, len, sizeof(char), compare);
    dfs(res, str, returnSize, tem, 0, flag);

    return res;
}