代码随想录day27| 39. 组合总和 、 40.组合总和II 、 131.分割回文串

39. 组合总和

int* path;
int pathTop;
int** ans;
int ansTop;

int* length;

void backTracking(int target, int index, int* candidates, int candidatesSize, int sum) {

    if(sum >= target) {
   
        if(sum == target) {
            int* tempPath = (int*)malloc(sizeof(int) * pathTop);
            int j;
            for(j = 0; j < pathTop; j++) {
                tempPath[j] = path[j];
            }
            ans[ansTop] = tempPath;
            length[ansTop++] = pathTop;
        }
        return ;
    }

    int i;
    for(i = index; i < candidatesSize; i++) {

        sum+=candidates[i];
        path[pathTop++] = candidates[i];
        backTracking(target, i, candidates, candidatesSize, sum);
        sum-=candidates[i];
        pathTop--;
    }
}

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){

    path = (int*)malloc(sizeof(int) * 50);
    ans = (int**)malloc(sizeof(int*) * 200);
    length = (int*)malloc(sizeof(int) * 200);
    ansTop = pathTop = 0;
    backTracking(target, 0, candidates, candidatesSize, 0);

    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
    int i;
    for(i = 0; i < ansTop; i++) {
        (*returnColumnSizes)[i] = length[i];
    }
    return ans;
}

这道题和前几道题没有什么太大的区别，唯一的区别就是，元素是可以重复使用的

40.组合总和II

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int* path;
int pathTop;
int** ans;
int ansTop;
int* length;

int cmp(const void* a1, const void* a2){
    return *(int*)a1 - *(int*)a2;
}

void backtracking(int *candidates, int candidatesSize, int target, int sum, int startindex){
    if(sum >= target){
        if(sum == target){
            int* temp = (int*)malloc(sizeof(int)*pathTop);
            int j;
            for(j = 0; j < pathTop; j++){
                temp[j] = path[j];
                }
            ans[ansTop] = temp;
            length[ansTop++] = pathTop;
        }
        return; 
    }

    int i;
    for(i = startindex; i < candidatesSize; i++){
        if(i > startindex && candidates[i] == candidates[i-1])
            continue;
        path[pathTop++] = candidates[i];
        sum+=candidates[i];
        backtracking(candidates, candidatesSize, target, sum, i+1);
        sum -= candidates[i];
        pathTop--;
    }


}
int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) {
    path = (int*)malloc(sizeof(int)*50);
    ans = (int**)malloc(sizeof(int*)*100);
    length = (int*)malloc(sizeof(int)*100);
    pathTop = ansTop = 0;

    qsort(candidates,candidatesSize,sizeof(int),cmp);
    backtracking(candidates, candidatesSize,  target, 0, 0);

    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int)*ansTop);
    for(int i = 0; i < ansTop; i++){
        (*returnColumnSizes)[i] = length[i];
    }
    return ans;
}

这道题的和上一道题不同的地方是:要进行去重操作，一旦涉及到去重，那么就要对数组进行排序，然后这道题目的去重，去的是相同的结果，而不是去相同的元素，就是对树层进行去重

 131.分割回文串 

char** path;
int pathTop;
char*** ans;
int ansTop = 0;
int* ansSize;

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

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

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);
    ansTop = pathTop = 0;

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

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

这里先将进行切割，切割成多个字符串，然后再进行判断是否为回文串

递归终止条件是什么？

startindex其实是一条切割线