代码随想录算法训练营第二十七天|39. 组合总和、40. 组合总和 II、131. 分割回文串(×)

目录

39. 组合总和

40. 组合总和 II

131. 分割回文串(×)

---

39. 组合总和

题目描述：

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

 套回溯算法模板，在模板基础上修改backtracking()参数，都是一样的套路。

要注意的是：各个组合要返回的大小是不相同的，需要再定义一个数组来记录每个组合的长度。

int **ret;    //结果集
int ret_num;
int *path;    //记录各个组合
int path_num;
int *len;    //记录各个组合长度

void backtracking(int* c,int startIndex,int target,int candidatesSize){
    //总和>target 直接返回
    if(target<0)      return ;
    //符合条件的终止
    if(target==0){
        int* temp=(int*)malloc(sizeof(int)*path_num);
        for(int i=0;i<path_num;i++){
            temp[i]=path[i];
        }
        len[ret_num]=path_num;
        ret[ret_num++]=temp;
        return ;
    }
    for(int i=startIndex;i<candidatesSize;i++){
        //处理单层
        path[path_num++]=c[i];
        target-=c[i];
        //递归
        backtracking(c,i,target,candidatesSize);
        //回溯（需要把目标值再加回来）
        target+=c[i];
        path_num--;
    }
}
int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    path=(int*)malloc(sizeof(int)*40);
    len=(int*)malloc(sizeof(int)*150);
    ret=(int**)malloc(sizeof(int*)*150);
    path_num=ret_num=0;
    backtracking(candidates,0,target,candidatesSize);
    *returnSize=ret_num;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ret_num);
    for(int i=0;i<*returnSize;i++){
        (*returnColumnSizes)[i]=len[i];
    }
    return ret;
}

40. 组合总和 II

题目描述：

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。

思路和39.组合总和相同。

要求的不同点在于：结集中去除重复组合；每个元素只能使用一次。

因此对cnadidates数组排序后再进行递归回溯，进行剪枝操作。

对于剪枝的考虑：i!=startIndex或者i>startIndex两个条件都可以，这个要仔细地考虑明白。我觉得i!=startIndex更好理解。

int **ret;
int ret_num;
int *path;
int path_num;
int *len;

int cmp_int(const void* e1,const void* e2){
    return *(int*)e1-*(int*)e2;
}
void backtracking(int* c,int startIndex,int target,int candidatesSize){
    //总和>target 直接返回
    if(target<0)      return ;
    //符合条件的终止
    if(target==0){
        int* temp=(int*)malloc(sizeof(int)*path_num);
        for(int i=0;i<path_num;i++){
            temp[i]=path[i];
        }
        len[ret_num]=path_num;
        ret[ret_num++]=temp;
        return ;
    }
    for(int i=startIndex;i<candidatesSize;i++){
        //处理单层
        //重复值跳过 每个值用一次,也要保证当前值被用上
        if(i!=startIndex&&c[i]==c[i-1]){
            continue;
        }
        path[path_num++]=c[i];
        target-=c[i];
        //递归
        backtracking(c,i+1,target,candidatesSize);
        //回溯（需要把目标值再加回来）
        target+=c[i];
        path_num--;
    }
}
int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    path=(int*)malloc(sizeof(int)*40);
    len=(int*)malloc(sizeof(int)*150);
    ret=(int**)malloc(sizeof(int*)*150);
    path_num=ret_num=0;
    //对candidates数组排序
    qsort(candidates,candidatesSize,sizeof(int),cmp_int);
    backtracking(candidates,0,target,candidatesSize);
    *returnSize=ret_num;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ret_num);
    for(int i=0;i<*returnSize;i++){
        (*returnColumnSizes)[i]=len[i];
    }
    return ret;
}

131. 分割回文串(×)

题目描述：

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

1. 1. 可以在收割结果集的时候判断是否是回文串，也可以在单层处理的时候进行判断（是我没想到的），但后者，单层处理的时候判断是否为回文串更为高效。
2. 2. 在单层处理的过程中，startIndex就是切割线，相应的随着i++，分割出的子串也就是s[startIndex,i]。

这个题目要返回三维数组，C要处理的太多了我转不过来！学会思想，粘一个代码随想录的C代码。

char** path;
int path_num;
char*** ans;
int ans_num= 0;
int* ansSize;

//将path中的字符串全部复制到ans中
void copy() {
    //创建一个临时tempPath保存path中的字符串
    char** tempPath = (char**)malloc(sizeof(char*) * path_num);
    int i;
    for(i = 0; i < path_num; i++) {
        tempPath[i] = path[i];
    }
    //保存tempPath
    ans[ans_num] = tempPath;
    //将当前path的长度（path_num）保存在ansSize中
    ansSize[ans_num++] = path_num;
}

//判断字符串是否为回文字符串
bool isPalindrome(char* str, int startIndex, int endIndex) {
    //双指针法：当endIndex（右指针）的值比startIndex（左指针）大时进行遍历
    while(endIndex >= startIndex) {
        //若左指针和右指针指向元素不一样，返回False
        if(str[endIndex--] != str[startIndex++])
            return 0;
    }
    return 1;
}

//切割从startIndex到endIndex子字符串
char* cutString(char* str, int startIndex, int endIndex) {
    //开辟字符串的空间
    char* tempString = (char*)malloc(sizeof(char) * (endIndex - startIndex + 2));
    int i;
    int index = 0;
    //复制子字符串
    for(i = startIndex; i <= endIndex; i++)
        tempString[index++] = str[i];
    //用'\0'作为字符串结尾
    tempString[index] = '\0';
    return tempString;
}

void backTracking(char* str, int strLen,  int startIndex) {
    if(startIndex >= strLen) {
        //将path拷贝到ans中
        copy();
        return ;
    }

    int i;
    for(i = startIndex; i < strLen; i++) {
        //若从startIndex到i的子串是回文字符串，将其放入path中
        if(isPalindrome(str, startIndex, i)) {
            path[path_num++] = cutString(str, startIndex, i);
        }
        //若从startIndex到i的子串不为回文字符串，跳过这一层 
        else {
            continue;
        }
        //递归判断下一层
        backTracking(str, strLen, i + 1);
        //回溯，将path中最后一位元素弹出
        path_num--;
    }
}

char*** partition(char* s, int* returnSize, int** returnColumnSizes){
    int strLen = strlen(s);
    //因为path中的字符串最多为strLen个（即单个字符的回文字符串），所以开辟strLen个char*空间
    path = (char**)malloc(sizeof(char*) * strLen);
    //存放path中的数组结果
    ans = (char***)malloc(sizeof(char**) * 40000);
    //存放ans数组中每一个char**数组的长度
    ansSize = (int*)malloc(sizeof(int) * 40000);
    ans_num = path_num = 0;

    //回溯函数
    backTracking(s, strLen, 0);

    //将ansTop设置为ans数组的长度
    *returnSize = ans_num;
    //设置ans数组中每一个数组的长度
    *returnColumnSizes = (int*)malloc(sizeof(int) * ans_num);
    int i;
    for(i = 0; i < ans_num; ++i) {
        (*returnColumnSizes)[i] = ansSize[i];
    }
    return ans;
}