Pallindrome Partioning

/**
 * 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().
 */

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

int* length;

bool isPalindrome(char* s, int start, int end){
    for(int i=start, j=end; i<j; i++,j--){
        if(s[i]!=s[j]){
            return false;
        }
    }
    return true;
}

char* cutString(char* s, int start, int end){
    char* tmp=malloc(sizeof(char)*(end-start+2));
    int index=0;
    for(int i=start; i<=end; i++){
        tmp[index++]=s[i];
    }
    tmp[index]='\0';
    return tmp;
}

void backTracking(char* s, int startIndex){
    if(startIndex >= strlen(s)){
        char** tmp=malloc(sizeof(char*)*pathTop);
        for(int i=0; i<pathTop; i++){
            tmp[i]=path[i];
        }
        ans[ansTop]=tmp;
        length[ansTop++]=pathTop;
    }
    for(int i=startIndex; i<strlen(s); i++){
        if(isPalindrome(s, startIndex, i)){
            path[pathTop++]=cutString(s, startIndex, i);
        }else{
            continue;
        }
        backTracking(s, i+1);
        pathTop--;
    }
    
}
char *** partition(char * s, int* returnSize, int** returnColumnSizes){
    ans=malloc(sizeof(char**)*40000);
    path=malloc(sizeof(char*)*strlen(s));
    length=malloc(sizeof(int)*40000);
    ansTop=pathTop=0;
    
    backTracking(s, 0);
    
    *returnSize=ansTop;
    *returnColumnSizes=malloc(sizeof(int)*ansTop);
    for(int i=0; i<ansTop; i++){
        (*returnColumnSizes)[i]=length[i];
    }
    return ans;
    
    
}