[力扣c语言实现]78. 子集

78.子集

https://leetcode-cn.com/problems/subsets/

怎么样才能达到不能重复？

1.首先求这种相近于排列或者组合的题，那么就是常规的DFS或者BFS做法。
2.本题中，即要求不能重复，那么就需要对重复分支进行剪枝。剪枝如下

怎么用代码来实现剪枝？

首先，如图所示，那实现核心就选定深度搜索优先算法DFS，其次，既然要搜索所不重复子集，那么就要进行递归，递归次数和元素数目有关。

下面就是DFS+递归的代码实现，我们主要关心如何实现剪枝而达到去重的目的

void DFS(int *nums,int numsSize,int *visited,int *returnSize,int **returnColumnSizes,int ***ret_array,int *cur_ret_set,int *cur_size)
{
    
    
	int newvisited[10] = {
    
    0};//这个数组的必要性
    int i = 0;
	int j = 0;
    
 	if (*cur_size > 0)
    {
    
    
        (*ret_array) = realloc((*ret_array),sizeof(int *)*(*returnSize+1));
        (*ret_array)[*returnSize] = (int *)malloc(sizeof(int)*(*cur_size));
		
        for (i = 0 ;i < *cur_size;i++)
        {
    
    
            (*ret_array)[*returnSize][i] = cur_ret_set[i];
        }
        
        (*returnColumnSizes) = realloc((*returnColumnSizes),sizeof(int)*(*returnSize+1));
        (*returnColumnSizes)[*returnSize] = *cur_size;
                                                                                         
        (*returnSize) += 1;
    }
    
    for (i = 0;i < numsSize;i++)
    {
    
    
        if (visited[i] == 1)
        {
    
    
            continue;
        }
		
        cur_ret_set[*cur_size] = nums[i];
        (*cur_size) += 1;
        visited[i] = 1;
        
        for (j=0;j<= i;j++)//这里一定要思考明白为什么这么干！为什么这样能达到去重的目的
		{
    
    
			newvisited[j] = 1;
		}
        
DFS(nums,numsSize,newvisited,returnSize,returnColumnSizes,ret_array,cur_ret_set,cur_size);
        (*cur_size) -= 1;//回溯
		visited[i] = 0;//回溯
    }
}

以上代码，为何能实现剪枝

首先，我们仔细分析这个题目的要求和看上图。我们一般使用一个数组visite[n]（n要排列的元素的个数）来进行剪枝。以初始序列{1,2,3}来举例:第一次调用DFS()函数时，visited[3] = {0,0,0},for循环中，由于visited[0] = 0；所以我们可以递归调用DFS，如下图所示：

这个过程，我们通过数组visited[]，使得DFS过程中不会出现{1,1,1}这种过程，因为我们的visited数组是从上到下传递的，它告诉下层的DFS函数：上层的DFS使用了哪几个变量，你下层不能再使用，这就达到了去重的目的。

所以这里就存在一个问题，下层使用上层改变后的visited[]数组，且在它的执行过程中也会修改visited[]，但是，我们是递归调用的，调用结束后，函数会从下往上返回，由于下层也修改了visited[]数组，如果传递到上一层后，势必会造成上层的for中同层的其他元素执行DFS受到影响，所以，这告诉我们，下层不能修改上层的visited[]数组，即要下层不能修改上层的数组visited[]，又要下层在你上层的执行情况中接着执行，那么，上层只能拷贝一份传递给下层，这就达到了，相邻层总是下层受到上层的影响，而不会反之。

void DFS(....)
{
    
    
	int newvisited[10] = {
    
    0};//这个数组的必要性：不能让“下层”修改“上层"的数组，所以要备份后传递给下层
   	....   	....  略 	....   	....
    for (i = 0;i < numsSize;i++)
    {
    
    
        if (visited[i] == 1)
        {
    
    
            continue;
        }
       	....   	.... 略  	....   	...
        for (j=0;j<= i;j++)
		{
    
    
			newvisited[j] = 1;//备份自己的情况传递下去
		}
		....   	.... 略  	....   	....
    }
}

回溯：保证我们能进行所有情况的遍历的关键

我们在本层visited[i] == 0的情况下，执行后续的DFS,并使得visited[i] == 1,当后续的函数返回以后，每一层的改变，不应该影响到上一层的情况。所以visited[i]要重新归于0，所以代码如下：

void DFS(....)
{
    
    ....   	.... 略  	....   	....
    for (i = 0;i < numsSize;i++)
    {
    
    
       ....   	.... 略  	....   	....
        (*cur_size) += 1;
        visited[i] = 1;
       ....   	.... 略  	....   	....
	   DFS(....   	.... 略  	....   	....);
        (*cur_size) -= 1;//回溯
		visited[i] = 0;//回溯
    }
}

详细实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../common_use/PRINT_ARRAY/include/print_array.h"

void DFS(int *nums,int numsSize,int *visited,int *returnSize,int **returnColumnSizes,int ***ret_array,int *cur_ret_set,int *cur_size)
{
    
    
	int newvisited[10] = {
    
    0};//这个数组的必要性
    int i = 0;
	int j = 0;
 	if (*cur_size > 0)
    {
    
    
        (*ret_array) = realloc((*ret_array),sizeof(int *)*(*returnSize+1));
        (*ret_array)[*returnSize] = (int *)malloc(sizeof(int)*(*cur_size));
		
        for (i = 0 ;i < *cur_size;i++)
        {
    
    
            (*ret_array)[*returnSize][i] = cur_ret_set[i];
        }
        
        (*returnColumnSizes) = realloc((*returnColumnSizes),sizeof(int)*(*returnSize+1));
        (*returnColumnSizes)[*returnSize] = *cur_size;
                                                                                         
        (*returnSize) += 1;
    }
    
    for (i = 0;i < numsSize;i++)
    {
    
    
        if (visited[i] == 1)
        {
    
    
            continue;
        }
		
        cur_ret_set[*cur_size] = nums[i];
        (*cur_size) += 1;
        visited[i] = 1;
        
        for (j=0;j<= i;j++)
		{
    
    
			newvisited[j] = 1;
		}
        
DFS(nums,numsSize,newvisited,returnSize,returnColumnSizes,ret_array,cur_ret_set,cur_size);
        (*cur_size) -= 1;//回溯
		visited[i] = 0;//回溯
    }
}

int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    
    	
    int visited[10] = {
    
    0};
    int cur_num_set[10] = {
    
    0};
    int cur_set_size = 0;
    int *ret_col_size = NULL;
    int** ret_array = NULL;
    
    *returnSize = 0;
    ret_array = (int **)malloc(sizeof(int* )*(*returnSize+1));
    ret_array[*returnSize] = (int *)malloc(sizeof(int));
    
    ret_col_size = realloc(ret_col_size,sizeof(int)*(*returnSize+1));
    ret_col_size[*returnSize] = 0;//第一个子集中的元素个数为0
	
    (*returnSize)++;//子集元素+1
	
	DFS(nums,numsSize,&visited[0],returnSize,&ret_col_size,&ret_array,cur_num_set,&cur_set_size);
	*returnColumnSizes = ret_col_size;
	
    return ret_array;
}


int main()
{
    
    
	int nums[] = {
    
    1,2,3};
	int numsSize = sizeof(nums)/sizeof(nums[0]);
	int**res = NULL;
	int returnSize = 0;
	int *returnColumnSizes = NULL;
	
	res = subsets(nums,numsSize, &returnSize,&returnColumnSizes);
	
	print_twodim_array(res,returnSize,returnColumnSizes);

	return 0;
}

用于输出一、二维数组的辅助调试函数

void print_onedim_array(int *g,int size)
{
    
    
	printf("\n\n");
	int i = 0;
	for (i = 0; i < size -1;i++)
	{
    
    
		printf("%d,",g[i]);
	}
	
	printf("%d\t\n",g[size-1]);
}

void print_twodim_array(int**ppg,int size,int *col_size)
{
    
    
	printf("\n\n");
	int i = 0;
	for (i = 0; i < size;i++)
	{
    
    
		print_onedim_array(ppg[i],col_size[i]);
	}
}