【例题1】2643. 一最多的行 - 力扣（LeetCode）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* rowAndMaximumOnes(int** mat, int matSize, int* matColSize, int* returnSize){
    int* arr = (int*)malloc(sizeof(int)*2);
    *returnSize = 2;
    arr[0] = 0;arr[1] = 0;
    for(int i=0;i<matSize;i++){
        int count = 0;
        for(int j=0;j<*matColSize;j++){
            if(mat[i][j] == 1) count++;
        }
        if(count > arr[1]){
            arr[0] = i;
            arr[1] = count;
        }
    }
    return arr;
}

【例题2】329. 矩阵中的最长递增路径 - 力扣（LeetCode）

int dp[210][210];// 记录从未知点出发到当前位置所能得到的最长递增路径

//规定方向
int dir[4][2] = {
    // y x
    //上 右 下 左
    {-1,0},{0,1},{1,0},{0,-1}
};

//深度优先搜索
int dfs(int y,int x,int** matrix,int r,int c){
    int i,ret = 1;
    for(i=0;i<4;i++){
        int dest_x = x+dir[i][1];
        int dest_y = y+dir[i][0];
        if(dest_x < 0 || dest_x >= c || dest_y < 0 || dest_y >= r) continue;
        if(matrix[dest_y][dest_x] < matrix[y][x]){
            if(dp[dest_y][dest_x] == -1){
                dp[dest_y][dest_x] = dfs(dest_y,dest_x,matrix,r,c);
            }
            if(dp[dest_y][dest_x] + 1 > ret){
                ret = dp[dest_y][dest_x] + 1;
            }
        }
    }
    return ret;
}

int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize){
    int r = matrixSize;
    int c = matrixColSize[0];
    int i,j,max=0;
    memset(dp,-1,sizeof(dp));
    for(i=0;i<r;i++){
        for(j=0;j<c;j++){
            if(dp[i][j]=-1){
                dp[i][j] = dfs(i,j,matrix,r,c);
            }
            if(dp[i][j]>max){
                max = dp[i][j];
            }
        }
    }
    return max;
}

【例题3】LCP 07. 传递信息 - 力扣（LeetCode）

//深度优先搜索
int dfs(int cur,int next ,int k, int** relation,int r, int n){
    if(k == 0 ){
        if(next == n-1) return 1;
        else return 0;
    }
    int ans=0;
    for(int i=0;i<r;i++){
        if(relation[i][0] == next){
            ans+=dfs(relation[i][0],relation[i][1],k-1,relation,r,n);
        }
    }
    return ans;
}

int numWays(int n, int** relation, int relationSize, int* relationColSize, int k){
    int r = relationSize;
    int c = relationColSize[0];
    //从编号0出发
    int ans = 0;
    for(int i=0;i<r;i++){
        int cur = relation[i][0];
        int next = relation[i][1];
        if(cur == 0){ // 从0开始的结点进入递归
            ans += dfs(cur,next,k-1,relation,r,n);
        }
    }
    return ans;
}

【例题4】41. 缺失的第一个正数 - 力扣（LeetCode）

int firstMissingPositive(int* nums, int numsSize){
    int arr[numsSize+1];
    memset(arr,-1,sizeof(arr));
    for(int i=0;i<numsSize;i++){
        // 如果当前数在范围内
        if(nums[i]>0 && nums[i]<numsSize+1) {
            arr[nums[i]] = 1;
        }
    }
    for(int i=1;i<numsSize+1;i++){
        if(arr[i]!=1){
            return i;
        }
    }
    return numsSize+1;
}

【例题5】387. 字符串中的第一个唯一字符 - 力扣（LeetCode）

int firstUniqChar(char * s){
    int Hash[26];
    memset(Hash,0,sizeof(Hash));
    for(int i=0;s[i];i++){
        Hash[s[i]-'a']++;
    }
    for(int i=0;s[i];i++){
        if(Hash[s[i]-'a'] == 1) return i;
    }
    return -1;
}