当前位置： 首页 > news >正文

拷打字节算法面试官之-深入c语言递归算法

news 2025/9/17 9:09:44

继续更新拷打面试官系列：c语言 递归算法系列7

***附录：5*200-> 1000行源码 

1 无重复的字符串全排列：

// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  *
//  * @param num int整型一维数组
//  * @param numLen int num数组长度
//  * @return int整型二维数组
//  * @return int* returnSize 返回数组行数
//  * @return int** returnColumnSizes 返回数组列数
//  */// //  #2刷
// int compareFn(const void *a, const void *b)
// {
//     return *(int *)a - *(int *)b;
// }// void doFunc(int *num, int numLen, int **res, int *returnSize, int *path, int depth, int *used)
// {
//     // if (depth == numLen)
//     // {
//     //     res[*returnSize] = (int *)malloc(numLen * sizeof(int));
//     //     for (int i = 0; i < numLen; i++)
//     //     {
//     //         res[*returnSize][i] = path[i];
//     //     }
//     //     (*returnSize) += 1;
//     // }
//     // else
//     // {
//     //     for (int i = 0; i < numLen; i++)
//     //     {
//     //         if (used[i] != 1)
//     //         {
//     //             used[i] = 1;
//     //             path[depth] = num[i];
//     //             doFunc(num, numLen, res, returnSize, path, depth + 1, used);
//     //             used[i] = 0;
//     //         }
//     //     }
//     // }//     // #3刷
//     if (depth == numLen)
//     {
//         res[*returnSize] = (int *)malloc(numLen * sizeof(int));
//         for (int i = 0; i < numLen; i++)
//         {
//             res[*returnSize][i] = path[i];
//         }
//         (*returnSize)++;
//     }
//     else
//     {
//         for (int i = 0; i < numLen; i++)
//         {
//             if (used[i] == 0)
//             {
//                 used[i] = 1;
//                 path[depth] = num[i];
//                 doFunc(num, numLen, res, returnSize, path, depth + 1, used);
//                 used[i] = 0;
//             }
//         }
//     }
// }// int **permute(int *num, int numLen, int *returnSize, int **returnColumnSizes)
// {
//     // write code here//     // 2025.7.9 3：06am
//     // # 2刷
//     // res是结果的二维数组，returnSize返回的大小，path目前的路径，depth是路径深度，used用来标记已经访问的数组
//     int total = 1;
//     for (int i = 1; i <= numLen; i++)
//     {
//         total *= i;
//     }
//     int depth = 0;
//     int **res = (int **)malloc(total * sizeof(int *));
//     int *path = (int *)malloc(numLen * sizeof(int));
//     int *used = (int *)calloc(numLen, sizeof(int));
//     qsort(num, numLen, sizeof(int), compareFn);
//     *returnSize = 0;
//     doFunc(num, numLen, res, returnSize, path, depth, used);//     *returnColumnSizes = (int *)malloc((*returnSize) * sizeof(int));
//     for (int i = 0; i < *returnSize; i++)
//     {//         (*returnColumnSizes)[i] = numLen;
//     }
//     return res;
// }/// 3刷
//!!!vip #self
/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可*** @param num int整型一维数组* @param numLen int num数组长度* @return int整型二维数组* @return int* returnSize 返回数组行数* @return int** returnColumnSizes 返回数组列数*/void fun(int *num, int numLen, int **res, int *used, int *temp, int pos, int *returnSize, int **returnColumnSizes)
{// 3刷//  if (pos == numLen)//  {//      for (int i = 0; i < numLen; i++)//      {//          res[*returnSize][i] = temp[i];//      }//      //!!!vip 错了又//      (*returnColumnSizes)[*returnSize] = numLen;//      (*returnSize)++;//      return;//  }// for (int i = 0; i < numLen; i++)// {//     if (used[i] != 1)//     {//         used[i] = 1;//         temp[pos] = num[i];//         fun(num, numLen, res, used, temp, pos + 1, returnSize, returnColumnSizes);//         used[i] = 0;//     }// }// 4刷if (pos == numLen){for (int i = 0; i < numLen; i++){res[*returnSize][i] = temp[i];}(*returnColumnSizes)[*returnSize] = numLen;(*returnSize)++;return;}else{for (int i = 0; i < numLen; i++){if (used[i] != 1){used[i] = 1;temp[pos] = num[i];fun(num, numLen, res, used, temp, pos + 1, returnSize, returnColumnSizes);used[i] = 0;}}}
}int **permute(int *num, int numLen, int *returnSize, int **returnColumnSizes)
{// 3刷 25年9月2号左右//  write code here//  if (num == NULL || numLen == 0)//  {//      *returnSize = 0;//      //!!!vip解引用之后才空//      *returnColumnSizes = NULL;//      return NULL;//  }// *returnSize = 0;// int maxSize = 1;// for (int i = 1; i <= numLen; i++)// {//     maxSize *= i;// }// int **res = (int **)malloc(maxSize * sizeof(int *));// for (int i = 0; i < maxSize; i++)// {//     res[i] = (int *)malloc(numLen * sizeof(int));// }// (*returnColumnSizes) = (int *)malloc(maxSize * sizeof(int));// int *used = (int *)calloc(numLen, sizeof(int));// int *temp = (int *)malloc(numLen * sizeof(int));// int pos = 0;// fun(num, numLen, res, used, temp, pos, returnSize, returnColumnSizes);// return res;// 4刷 25年9月15*returnSize = 0;int i = 1, maxSize = 1;while (i <= numLen){maxSize = i * maxSize;i++;}int **res = (int **)malloc(maxSize * sizeof(int *));for (int i = 0; i < maxSize; i++){res[i] = (int *)malloc(numLen * sizeof(int));}*returnColumnSizes = (int *)malloc(maxSize * sizeof(int));int *used = (int *)calloc(numLen, sizeof(int));int *temp = (int *)malloc(numLen * sizeof(int));fun(num, numLen, res, used, temp, 0, returnSize, returnColumnSizes);return res;
}

2 岛屿数量

思路： 函数里找到一个就把used置1，然后用fun函数一个个找

// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  * 判断岛屿数量
//  * @param grid char字符型二维数组
//  * @param gridRowLen int grid数组行数
//  * @param gridColLen int* grid数组列数
//  * @return int整型
//  */
// #include <stdio.h>
// #include <stdlib.h>
// // void dfs(char **grid, int i, int j, int row, int col)
// // {
// //     // 不在范围内,不做处理
// //     if (i < 0 || i >= row || j < 0 || j >= col || grid[i][j] == '0')
// //     {
// //         return;
// //     }
// //     // 处理掉为0
// //     grid[i][j] = '0';
// //     // 四个方向搜索
// //     dfs(grid, i - 1, j, row, col);
// //     dfs(grid, i + 1, j, row, col);
// //     dfs(grid, i, j - 1, row, col);
// //     dfs(grid, i, j + 1, row, col);
// // }// // int solve(char **grid, int gridRowLen, int *gridColLen)
// // {
// //     // write code here
// //     // 直接dfs
// //     int count = 0;
// //     for (int i = 0; i < gridRowLen; i++)
// //     {
// //         for (int j = 0; j < *gridColLen; j++)
// //         {
// //             if (grid[i][j] == '1')
// //             {
// //                 dfs(grid, i, j, gridRowLen, *gridColLen);
// //                 count++;
// //             }
// //         }
// //     }
// //     return count;
// // }// // # 2刷
// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  * 判断岛屿数量
//  * @param grid char字符型二维数组
//  * @param gridRowLen int grid数组行数
//  * @param gridColLen int* grid数组列数
//  * @return int整型
//  */
// void doFunc(char **grid, int i, int j, int Row, int *Col)
// {//     if (i < 0 || i >= Row || j < 0 || j >= *Col || grid[i][j] == '0')
//     {
//         return;
//     }
//     grid[i][j] = '0';
//     int dir[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
//     for (int t = 0; t < 4; t++)
//     {
//         doFunc(grid, i + dir[t][0], j + dir[t][1], Row, Col);
//     }
// }// int solve(char **grid, int gridRowLen, int *gridColLen)
// {
//     int cnt = 0;
//     // write code here
//     for (int i = 0; i < gridRowLen; i++)
//     {
//         for (int j = 0; j < *gridColLen; j++)
//         {
//             if (grid[i][j] == '1')
//             {
//                 doFunc(grid, i, j, gridRowLen, gridColLen);
//                 cnt++;
//             }
//         }
//     }
//     return cnt;
// }// #3刷/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** 判断岛屿数量* @param grid char字符型二维数组* @param gridRowLen int grid数组行数* @param gridColLen int* grid数组列数* @return int整型*/void fun(char **grid, int row, int *col, int **used, int i, int j)
{// 3刷//  if (i < 0 || i >= row || j < 0 || j >= (*col) || used[i][j] == 1 || grid[i][j] == '0')//  {//      return;//  }//  used[i][j] = 1;//  int newi = 0, newj = 0;//  int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};//  int res = 0;//  for (int k = 0; k < 4; k++)//  {//      newi = i + dir[k][0];//      newj = j + dir[k][1];//      // 4个方向都探索//      if (newi >= 0 && newi < row && newj >= 0 && newj < *col && used[newi][newj] == 0 && grid[newi][newj] == '1')//      {//          used[newi][newj] = 1;//          // grid[newi][newj] = '0';//          fun(grid, row, col, used, newi, newj, count);//      }//  }// 4刷if (i < 0 || i >= row || j < 0 || j >= *col || used[i][j] == 1 || grid[i][j] = 0){return;}used[i][j] = 1;int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};for (int k = 0; k < 4; k++){int ni = i + dir[k][0];int nj = j + dir[k][1];if (ni >= 0 && ni < row && nj >= 0 && nj < *col && used[ni][nj] != 1){used[ni][nj] = 1;fun(grid, row, col, used, ni, nj);}}
}int solve(char **grid, int gridRowLen, int *gridColLen)
{// // write code here// int **used = (int **)malloc(gridRowLen * sizeof(int *));// for (int i = 0; i < gridRowLen; i++)// {//     used[i] = (int *)calloc((*gridColLen), sizeof(int));// }// // 分配used[r][c]的使用数组,标记是否访问过// // 根据是否访问过，直接钻进去访问// int count = 0;// int res = 0;// for (int i = 0; i < gridRowLen; i++)// {//     for (int j = 0; j < *gridColLen; j++)//     {//         if (used[i][j] == 0 && grid[i][j] == '1')//         {//             used[i][j] = 1;//             res += 1;//             fun(grid, gridRowLen, gridColLen, used, i, j, &count);//         }//     }// }// return res;//!!!v 4刷 25 9.15int **used = (int **)malloc(gridRowLen * sizeof(int *));for (int i = 0; i < gridRowLen; i++){used[i] = (int *)calloc((*gridColLen), sizeof(int));}int res = 0;if (grid == NULL || gridRowLen == 0){return res;}for (int i = 0; i < gridRowLen; i++){for (int j = 0; j < *gridColLen; j++){if (used[i][j] != 1 && grid[i][j] == 1){res += 1;fun(grid, gridRowLen, gridColLen, used, i, j);}}}return res;
}

3 括号生成：

思路 ： 一个个去试，把（ 或者）一个个放进去：left<n或者right<left&& right<n 就可以放进去：

/*#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// void doFunc(char **res, int *returnSize, char *current, int pos, int left, int right, int len)
// {//     if (left == len && right == len)
//     {
//         // 创建space
//         res[*returnSize] = (char *)malloc((len * 2 + 1) * sizeof(char));
//         strcpy(res[*returnSize], current);
//         (*returnSize)++;
//         return;
//     }
//     if (left < len)
//     {
//         // 这里要是字符串
//         //  #self vip
//         current[pos] = '(';
//         doFunc(res, returnSize, current, pos + 1, left + 1, right, len);
//         // 字符串产犊strlen
//         //  current[strlen(current)-1]= '\0';
//     }
//     if (right < left)
//     {
//         current[pos] = ')';//         doFunc(res, returnSize, current, pos + 1, left, right + 1, len);
//         // current[strlen(current)-1] = '\0';
//     }
// }// #2刷
void doFunc(char **res, int *returnSize, char *current, int len, int left, int right, int numLen)
{if (len == 2 * numLen){current[len] = '\0';res[*returnSize] = (int *)malloc((2 * numLen + 1) * (sizeof(char)));for (int i = 0; i < 2 * numLen; i++){res[*returnSize][i] = current[i];}(*returnSize)++;}else{if (left < numLen){current[len] = '(';doFunc(res, returnSize, current, len + 1, left + 1, right, numLen);}if (right < numLen && right < left){current[len] = ')';doFunc(res, returnSize, current, len + 1, left, right + 1, numLen);}}
}char **generateParenthesis(int n, int *returnSize)
{// write code hereprintf("开始生成！\n");int returnCount = 1 << (2 * n);*returnSize = 0;char **res = (char **)malloc(returnCount * sizeof(char *));char *current = (char *)malloc(2 * n + 1 * sizeof(char));doFunc(res, returnSize, current, 0, 0, 0, n);return res;
}int main()
{int len = 5;int returnSize;char **res = generateParenthesis(len, &returnSize);for (int i = 0; i < returnSize; i++){printf("%s \n", res[i]);}return 0;
}// self  !!!!!vip
// 步骤	递归调用	current	操作	说明
// 1	doFunc(0,0,0)	""	添加 '('	进入第一个分支
// 2	doFunc(1,1,0)	"("	添加 '('	继续深入左括号分支
// 3	doFunc(2,2,0)	"(("	添加 ')'	开始添加右括号
// 4	doFunc(3,2,1)	"(()"	添加 ')'	完成 "(())" 组合
// 5	doFunc(4,2,2)	"(())"	保存结果	returnSize=1，开始回溯
// 回溯步骤
// 6	返回 doFunc (3,2,1)	"(()"	无更多操作	回溯到上一层
// 7	返回 doFunc (2,2,0)	"(("	无更多操作	回溯到上一层
// 8	返回 doFunc (1,1,0)	"("	覆盖 '(' → ')'	尝试新分支，current = "()"
// 9	doFunc(2,1,1)	"()"	添加 '('	开始新路径**//* !!! vip 3刷*//*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可*** @param n int整型* @return string字符串一维数组* @return int* returnSize 返回数组行数*/void fun(int n, char **res, char *temp, int *returnSize, int left, int right, int index)
{// if (index == 2 * n)// {//     temp[2 * n] = '\0';//     res[*returnSize] = (char *)malloc((2 * n + 1) * sizeof(char));//     // res[*returnSize] = temp;//     strcpy(res[*returnSize], temp);//     (*returnSize) += 1;//     return;// }// if (left < n)// {//     temp[index++] = '(';//     fun(n, res, temp, returnSize, left + 1, right, index);// }// if (right < left)// {//     temp[index++] = ')';//     fun(n, res, temp, returnSize, left, right, index);// }//!!!4th 刷if (index == 2 * n){// 放进去strcpy(res[*returnSize], temp);res[*returnSize][2 * n] = '\0';(*returnSize)++;return;}if (left < n){temp[index] = '(';fun(n, res, temp, returnSize, left + 1, right, index + 1);}if (right < left && right < n){temp[index] = ')';fun(n, res, temp, returnSize, left, right + 1, index + 1);}
}char **generateParenthesis(int n, int *returnSize)
{// write code here// *returnSize = 0;// if (n == 0)// {//     return NULL;// }// char **res = (char **)malloc(100000 * sizeof(char *));// char *temp = (char *)malloc((2 * n + 2) * sizeof(char));// fun(n, res, temp, returnSize, 0, 0, 0);// return res;// ！！！ 4刷*returnSize = 0;char **res = (char **)malloc(10000 * sizeof(char *));for (int i = 0; i < 10000; i++){res[i] = (char *)malloc((2 * n + 1) * sizeof(char));}char *temp = (char *)malloc((2 * n + 1) * sizeof(char));fun(n, res, temp, returnSize, 0, 0, 0);return res;
}

4 最长递增路径：

思路：一个个去找，maxlen随着fun函数调用不断更新，fun函数里面直接迭代下一次递归，要满足增长 且 在范围内才可以，maxLen>tempLen + 1 才可以增加，dp[newi][newj]= maxLen ,返回这个结果并更新dp矩阵

// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  * 递增路径的最大长度
//  * @param matrix int整型二维数组 描述矩阵的每个数
//  * @param matrixRowLen int matrix数组行数
//  * @param matrixColLen int* matrix数组列数
//  * @return int整型
//  */
// #include <stdio.h>
// #include <stdlib.h>
// int dir[4][2] = {
//     {1, 0}, {-1, 0}, {0, 1}, {0, -1}};// int dfs(int **m, int **memo, int x, int y, int r, int *c)
// {
//     if (memo[x][y] != 0)
//     {
//         return memo[x][y];
//     }
//     int maxLen = 1;
//     for (int i = 0; i < 4; i++)
//     {
//         int x1 = x + dir[i][0];
//         int y1 = y + dir[i][1];
//         if (x1 >= 0 && x1 < r && y1 >= 0 && y1 < *c && m[x1][y1] > m[x][y])
//         {
//             int len = 1 + dfs(m, memo, x1, y1, r, c);
//             if (len > maxLen)
//             {
//                 maxLen = len;
//             }
//         }
//     }
//     memo[x][y] = maxLen;
//     return memo[x][y];
// }// int solve(int **matrix, int matrixRowLen, int *matrixColLen)
// {
//     // write code here//     int maxLen = 1;
//     int r = matrixRowLen;
//     int *c = matrixColLen;//     int **memo = (int **)malloc(r * sizeof(int *));
//     for (int i = 0; i < r; i++)
//     {
//         memo[i] = (int *)malloc((*c) * sizeof(int));
//     }
//     for (int i = 0; i < r; i++)
//     {//         for (int j = 0; j < *c; j++)
//         {//             memo[i][j] = 0;
//         }
//     }//     for (int i = 0; i < r; i++)
//     {
//         for (int j = 0; j < *c; j++)
//         {
//             int len = dfs(matrix, memo, i, j, r, c);
//             if (len > maxLen)
//             {
//                 maxLen = len;
//             }
//         }
//     }
//     return maxLen;
// }// int main()
// {
//     int arr[][4] = {
//         {1, 2, 3, 4},
//         {4, 5, 6, 5},
//         {7, 8, 9, 47}//     };
//     int r = sizeof(arr) / sizeof(arr[0]);
//     int c = sizeof(arr[0]) / sizeof(arr[0][0]);//     int **matrix = (int **)malloc(r * sizeof(int *));
//     for (int i = 0; i < r; i++)
//     {
//         matrix[i] = arr[i];
//     }//     // int** memo[ ;
//     printf("%d \n", solve(matrix, r, &c));
// }// #self !!!vip
//  redo 2ndtime// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  * 递增路径的最大长度
//  * @param matrix int整型二维数组 描述矩阵的每个数
//  * @param matrixRowLen int matrix数组行数
//  * @param matrixColLen int* matrix数组列数
//  * @return int整型
//  */
// int dir[4][2] = {
//     {0, 1}, {0, -1}, {1, 0}, {-1, 0}};// int dfs2(int **matrix, int** memo, int x, int y, int r, int *c)
// {
//     int maxLen = 1;
//     if (memo[x][y] != 0)
//     {
//         return memo[x][y];
//     }
//     // 在四个方向上探索：
//     int x1 = 0;
//     int y1 = 0;
//     for (int i = 0; i < 4; i++)
//     {
//         // new x+ y
//         x1 = x + dir[i][0];
//         y1 = y + dir[i][1];
//         // 如果matrix范围内 and 新的>老的 , len = 1+dfs(xnew+ynew),
//         //  iflen > maxLen ,直接跟新
//         if (x1 >= 0 && x1 < r && y1 >= 0 && y1 < *c && matrix[x1][y1] > matrix[x][y])
//         {
//             int len = 1 + dfs2(matrix, memo, x1, y1, r, c);
//             if(len>maxLen ){
//                 maxLen = len;
//             }
//         }
//     }
//     // 记录memod 新状态
//     memo[x][y] = maxLen;
//     // 返回
//     return maxLen;
// }// int solve1(int **matrix, int matrixRowLen, int *matrixColLen)
// {
//     // write code here
//     if(matrixRowLen==0 ){
//         return  0 ;
//     }
//     int n =matrixRowLen*(*matrixColLen);
//     // self !!!vip
//     //粗心：二维数组应该是里面的个数，也就是：row那么多个二维数组
//     //里面的也是int*类型的数据
//     int** memo = (int**)malloc(matrixRowLen*sizeof(int*));
//     for(int i = 0 ;i<matrixRowLen ;i++){
//         memo[i] = (int*)malloc((*matrixColLen)*sizeof(int));
//     }//     int maxLen = 0 ;
//     for(int i = 0 ;i<matrixRowLen;i++){
//         for(int j =0;j<*matrixColLen;j++){
//             int len = dfs2(matrix,memo,i,j,matrixRowLen,matrixColLen);
//             if(len>maxLen){
//                 maxLen = len ;
//             }
//         }
//     }
//     return maxLen ;
// }// #3刷// int dir[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};// int doFunc(int **matrix, int i, int j, int **used, int **memo, int R, int *C)
// {
// if (i < 0 || i >= R || j < 0 || j >= *C || used[i][j] == 1)
// {
//     return 0;
// }
// used[i][j] = 1;
// int maxNow = 0;
// int newi = 0, newj = 0;
// for (int k = 0; k < 4; k++)
// {
//     newi = i + dir[k][0];
//     newj = j + dir[k][1];
//     if (used[newi][newj] == 0 && newi >= 0 && newi < R && newj >= 0 && newj < *C && matrix[newi][newj] > matrix[i][j])
//     {
//         // 容易错
//         int temp = doFunc(matrix, newi, newj, used, memo, R, C);
//         if (temp > maxNow)
//         {
//             maxNow = temp;
//         }
//     }
// }
// memo[i][j] = maxNow + 1;
// used[i][j] = 0;
// return memo[i][j];// #2刷
//     if (i < 0 || i >= R || j < 0 || j >= *C || used[i][j] == 1)
//     {
//         return 0;
//     }
//     if (memo[i][j] != 0)
//     {
//         return memo[i][j];
//     }
//     used[i][j] = 1;
//     int newi = 0, newj = 0;
//     int tempMax = 0;
//     for (int k = 0; k < 4; k++)
//     {
//         newi = i + dir[k][0];
//         newj = j + dir[k][1];
//         if (newi >= 0 && newi < R && newj >= 0 && newj < *C && matrix[newi][newj] > matrix[i][j])
//         {
//             int subLen = doFunc(matrix, newi, newj, used, memo, R, C);
//             if (subLen > tempMax)
//             {
//                 tempMax = subLen;
//             }
//         }
//     }
//     used[i][j] = 0;
//     memo[i][j] = tempMax + 1;
//     return tempMax + 1;
// }
// int solve(int **matrix, int matrixRowLen, int *matrixColLen)
// {
//     // write code here
//     int **used = (int **)malloc(matrixRowLen * sizeof(int *));
//     for (int i = 0; i < matrixRowLen; i++)
//     {
//         used[i] = (int *)calloc((*matrixColLen), sizeof(int));
//     }//     int **memo = (int **)malloc(matrixRowLen * sizeof(int *));
//     for (int i = 0; i < matrixRowLen; i++)
//     {
//         memo[i] = (int *)calloc((*matrixColLen), sizeof(int));
//     }//     // int maxLen = 0;
//     // for (int i = 0; i < matrixRowLen; i++)
//     // {
//     //     for (int j = 0; j < *matrixColLen; j++)
//     //     {
//     //         int temp = doFunc(matrix, i, j, used, memo, matrixRowLen, matrixColLen);
//     //         if (temp > maxLen)
//     //         {
//     //             maxLen = temp;
//     //         }
//     //     }
//     // }
//     int maxLen = 1;
//     for (int i = 0; i < matrixRowLen; i++)
//     {
//         for (int j = 0; j < *matrixColLen; j++)
//         {
//             int tempMax = doFunc(matrix, i, j, used, memo, matrixRowLen, matrixColLen);
//             if (tempMax > maxLen)
//             {
//                 maxLen = tempMax;
//             }
//         }
//     }
//     return maxLen;
// }// # 4刷 25.9.6/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** 递增路径的最大长度* @param matrix int整型二维数组 描述矩阵的每个数* @param matrixRowLen int matrix数组行数* @param matrixColLen int* matrix数组列数* @return int整型*/int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};int fun(int **m, int r, int *c, int **dp, int i, int j)
{// 4刷//  if (i < 0 || i >= r || j < 0 || j >= c)// {//     return 0;// }// if (dp[i][j] != 0)// {//     return dp[i][j];// }// int max_Len = 1;// int newi = 0, newj = 0;// for (int k = 0; k < 4; k++)// {//     newi = i + dir[k][0];//     newj = j + dir[k][1];//     if (newi >= 0 && newi < r && newj >= 0 && newj < c && m[newi][newj] > m[i][j])//     {//         int temp = dfs(m, r, c, dp, newi, newj);//         if (temp + 1 > max_Len)//         {//             dp[i][j] = temp + 1;//             max_Len = dp[i][j];//         }//     }// }// dp[i][j] = max_Len;// return dp[i][j];// 5刷if (i < 0 || i >= r || j < 0 || j >= *c){return 0;}int maxLen = 1;if (dp[i][j] != 0){return dp[i][j];}for (int k = 0; k < 4; k++){int ni = i + dir[k][0];int nj = j + dir[k][1];if (ni >= 0 && ni < r && nj >= 0 && nj < *c && m[ni][nj] > m[i][j]){int tempLen = fun(m, r, c, dp, ni, nj);if (tempLen + 1 > maxLen){dp[i][j] = tempLen + 1;maxLen = dp[i][j];}}}return maxLen;
}int solve(int **matrix, int matrixRowLen, int *matrixColLen)
{// write code here// if (matrix == NULL || matrixRowLen == 0 || *matrixColLen == 0)// {//     return 0;// }// int **dp = (int **)malloc(matrixRowLen * sizeof(int *));// for (int i = 0; i < matrixRowLen; i++)// {//     dp[i] = (int *)calloc(*matrixColLen, sizeof(int));// }// int r = matrixRowLen, c = *matrixColLen;// int maxLen = 1;// for (int i = 0; i < r; i++)// {//     for (int j = 0; j < c; j++)//     {//         int tempLen = dfs(matrix, r, c, dp, i, j);//         if (tempLen > maxLen)//         {//             maxLen = tempLen;//         }//     }// }// return maxLen;// 5刷：2025.9.16 号2：25amif (matrix == NULL){return 0;}int **dp = (int **)malloc(matrixRowLen * sizeof(int *));for (int i = 0; i < matrixRowLen; i++){dp[i] = (int *)calloc((*matrixColLen), sizeof(int));}int maxLen = 1;for (int i = 0; i < matrixRowLen; i++){for (int j = 0; j < *matrixColLen; j++){int tempLen = fun(matrix, matrixRowLen, matrixColLen, dp, i, j);maxLen = (tempLen > maxLen) ? tempLen : maxLen;}}return maxLen;
}

关注+评论+收藏，免费获取本人手撸的2万行c语言源码+3刷代码！！！


文章转载自：

http://VsMs6k7f.fkgqn.cn
http://cVWLUmIr.fkgqn.cn
http://olMLf5Eb.fkgqn.cn
http://2kGcbPBt.fkgqn.cn
http://biOhXGbg.fkgqn.cn
http://4c13AaAY.fkgqn.cn
http://P6j4TNQw.fkgqn.cn
http://SbWBWIkB.fkgqn.cn
http://7OxIiSir.fkgqn.cn
http://xHrLa5eH.fkgqn.cn
http://ori4Kg5A.fkgqn.cn
http://kVGYusDB.fkgqn.cn
http://xEwh6TbR.fkgqn.cn
http://uS34P356.fkgqn.cn
http://O7fTXPIQ.fkgqn.cn
http://6lPnKgl4.fkgqn.cn
http://lcfJrayf.fkgqn.cn
http://lmiHpbos.fkgqn.cn
http://Q5c9xv0f.fkgqn.cn
http://VixgZblK.fkgqn.cn
http://fDJvYfg0.fkgqn.cn
http://X3Lx4khy.fkgqn.cn
http://kCCbBc2z.fkgqn.cn
http://jmsVFVg4.fkgqn.cn
http://wxU5FvI5.fkgqn.cn
http://EfaVB4bP.fkgqn.cn
http://EskUWSky.fkgqn.cn
http://nyByFh91.fkgqn.cn
http://0Q3HkXQw.fkgqn.cn
http://CkDMurag.fkgqn.cn
http://www.dtcms.com/a/386607.html

相关文章：

  • Vehiclehal的VehicleService.cpp
  • 【传奇开心果系列】基于Flet框架实现的允许调整大小的开关自定义组件customswitch示例模板特色和实现原理深度解析
  • 八股整理xdsm
  • SpringBoot 配置文件详解：从基础语法到实战应用
  • lesson62：JavaScript对象进化：ES2025新特性深度解析与实战指南
  • ARM C1-Premium core简介
  • 机器学习-深度神经网络架构
  • godot+c#实现玩家动画
  • 【Axure高保真原型】标签树分类查询案例
  • 系统架构设计(一)
  • RK3568下QT实简易文件浏览器
  • 设备综合效率（OEE）讲解与计算案例
  • STM32G4 电流环闭环(二) 霍尔有感运行
  • git-gui --批量处理文件
  • 【代码随想录day 28】 力扣 55.跳跃游戏
  • Python Flask 项目实战
  • whisper.cpp参数调优
  • C语言第13讲
  • brew install太慢的解决办法
  • vite+vue3中使用FFmpeg@0.12.15实现视频编辑功能，不依赖SharedArrayBuffer!!!
  • AI智能问数能力全面升级，DataEase开源BI工具v2.10.13 LTS版本发布
  • 【pytorch】tensor的定义与属性
  • 【问题】使用腾讯宝塔部署并启动Nodejs应用异常处理Cannot find module ‘express‘
  • vue-office 在线预览
  • 嵌入式基本概念：什么是指令集，微架构，IDE，DFP等等是什么意思，有什么关系？？？
  • Rust的Cargo用法详解
  • 基于51单片机煤气天然气检测阈值报警风扇设计
  • Go语言flag包详解
  • Golang语言入门篇005_命名规则与可见性
  • MySQL知识笔记