1.11 LeetCode总结（基本算法）_DFS之回溯算法

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

1. 复用DFS的思路，找递归终止条件等思路一致
2. 在找到满足条件的数组时，拷贝数组的手法值得学习

 /* 定义当前遍历深度count为全局变量 */
int gCount;
void DFS(int *nums, int numsSize, int depth, int *path, int *visited, int **res)
{
	// 递归终止条件，满足 depth == numSize
	if (depth == numsSize) {
		res[gCount] = (int *)malloc(sizeof(int) * numsSize);
		memcpy(res[gCount++], path, sizeof(int) * numsSize);
		return;
	}
	for (int i = 0; i < numsSize; i++) {
		// 如果已经遍历了，continue
		if (visited[i] == 1) {
			continue;
		}
		path[depth] = nums[i];
		visited[i] = 1;
		DFS(nums, numsSize, depth + 1, path, visited, res);
		visited[i] = 0;
	}
}
int **permute(int *nums, int numsSize, int *returnSize, int **returnColumnSizes) 
{
	(*returnSize) = 1; // 初始值
	gCount = 0;
	// 排列数 n!
	for (int i = 1; i <= numsSize; i++) {
		(*returnSize) *= i;
	}
	*returnColumnSizes = (int *)malloc(sizeof(int) * (*returnSize));
	for (int i = 0; i < (*returnSize); i++) {
		(*returnColumnSizes)[i] = numsSize;
	}
	int **res = (int **)malloc(sizeof(int *) * (*returnSize));
	int *path = (int *)malloc(sizeof(int) * numsSize);
	int *visited = (int *)malloc(numsSize * sizeof(int));
	DFS(nums, numsSize, 0, path, visited, res);
	return res;
}

36. 有效的数独

TBD 使用HASHMAP？

22.括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

回溯算法递归求解：
如果左括号数量不大于 n，我们可以放一个左括号。
如果右括号数量小于左括号的数量，我们可以放一个右括号。

#define MAX_SIZE  1430 // MAX_SIZE 应是一个卡特兰数，官方测试用例中 n 最多为 8，所以 MAX_SIZE = 1430 即可
void dfs(int left, int right, int n, char *str, int index, char **result, int *returnSize) 
{
  // 左右括号都用完
  if (left == n && right == n) {
    result[(*returnSize)] =  (char *)malloc((2 * n + 1)*sizeof(char));
    str[index] = '\0';
	strcpy(result[(*returnSize)++], str);
    return;
  }
  // 当左括号没用完时
  if (left < n) {
    str[index] = '(';
    dfs(left + 1, right, n, str, index + 1, result, returnSize);
  }
  // 右括号数量必须小于左括号，否则一定不合法，且右括号没有用完
  if (left > right && right < n) {
    str[index] = ')';
    dfs(left, right + 1, n, str, index + 1, result, returnSize);
  }
}
char **generateParenthesis(int n, int *returnSize) 
{
  char *str = (char*)malloc((2 * n + 1)*sizeof(char));
  char **result = (char **)malloc(sizeof(char *)*MAX_SIZE);
  *returnSize = 0;
  dfs(0, 0, n, str, 0, result, returnSize);
  return result;
}

448. 找到所有数组中消失的数字

给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。
找到所有在 [1, n] 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
//原地哈希
int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize)
{
    for (int i = 0; i < numsSize; i++) {
        if (nums[labs(nums[i])-1]>0) {
            nums[labs(nums[i])-1]*=-1;
        }
    }
    int *ret = (int *)malloc(sizeof(int )*numsSize);
    
    *returnSize=0;

    for (int i=0; i < numsSize; i++) {
        if (nums[i] > 0){
            ret[*returnSize]=i+1;
            (*returnSize)++;
        }
    }
    
    return ret;
}

遍历输入数组的每个元素一次。
我们将把 |nums[i]|-1 索引位置的元素标记为负数。即 nums[|nums[i] |- 1] \times -1nums[∣nums[i]∣−1]×−1 。
然后遍历数组，若当前数组元素 nums[i] 为负数，说明我们在数组中存在数字 i+1。

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

int candidatesSize_tmp;
int ansSize;
int combineSize;
int* ansColumnSize;

void dfs(int* candidates, int target, int** ans, int* combine, int idx) {
    if (idx == candidatesSize_tmp) {
        return;
    }
    if (target == 0) {
        int* tmp = malloc(sizeof(int) * combineSize);
        for (int i = 0; i < combineSize; ++i) {
            tmp[i] = combine[i];
        }
        ans[ansSize] = tmp;
        ansColumnSize[ansSize++] = combineSize;
        return;
    }
    // 直接跳过
    dfs(candidates, target, ans, combine, idx + 1);
    // 选择当前数
    if (target - candidates[idx] >= 0) {
        combine[combineSize++] = candidates[idx];
        dfs(candidates, target - candidates[idx], ans, combine, idx);
        combineSize--;
    }
}

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) {
    candidatesSize_tmp = candidatesSize;
    ansSize = combineSize = 0;
    int** ans = malloc(sizeof(int*) * 1001);
    ansColumnSize = malloc(sizeof(int) * 1001);
    int combine[2001];
    dfs(candidates, target, ans, combine, 0);
    *returnSize = ansSize;
    *returnColumnSizes = ansColumnSize;
    return ans;
}