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;
}
4792
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
