力扣刷题记录7（无算法背景，纯C语言）

37、最小路径和（64动态规划）

int minPathSum(int** grid, int gridSize, int* gridColSize) 
{

    int n = gridSize;//行
    int m = *gridColSize; //列
    if(n == 0|| m == 0)return 0;
    for(int i = 1; i < m ; i++)//把第一行的最短路径计算了
    {
        grid[0][i] += grid[0][i - 1];
    }
    for(int i = 1; i < n ; i++)
    {
        grid[i][0] += grid[i - 1][0];
    }
    for(int i = 1; i < n ; i++)
    {
        for(int j = 1; j < m ; j++)
        {
            grid[i][j] = grid[i][j] + fmin(grid[i][j - 1],grid[i - 1][j]);
        }
    }
    return grid[n-1][m-1];
}

38、打家劫舍（198动态规划）

int rob(int* nums, int numsSize) 
{
    if(numsSize == 0)return 0;
    int pre1 = nums[0];
    int pre2 = 0;
    for(int i = 1; i < numsSize; i++)
    {
        int current = fmax(pre1, pre2 + nums[i]);
        pre2 = pre1;
        pre1 = current;
    }
    return pre1;
}

39、跳跃游戏（55贪心）

保留最大步即可

bool canJump(int* nums, int numsSize) 
{
    if(numsSize <= 1)return true;
    int max = nums[0];
    for(int i = 1; i < numsSize - 1; i ++)
    {
        max -= 1; 
        if(max < 0) return false;
        if(max < nums[i])max = nums[i];
    }    
    if(max > 0)return true;
    return false;
}

40、跳跃游戏II（45贪心）

int jump(int* nums, int numsSize) 
{
    int distance = numsSize - 1 - nums[0];//离终点距离
    int position = 0;
    int count = 1;//计数
    if(numsSize <= 1)return 0;
    //从nums[i]的距离内选一个能跳最远的，每次++count
    while(distance > 0)
    {
        int new_position = 0;
        for(int i = position + 1; i <= (position + nums[position]); i++)
        {
            int new_distance = numsSize - i - 1 - nums[i];
            if(distance > new_distance)
            {
                distance = new_distance;
                new_position = i;
            }
        }
        position = new_position;
        count++;
    }
    return count;
}

41、腐烂的橘子（994广度优先搜索）

int orangesKuozhan(int** grid, int gridSize, int* gridColSize, int i, int j)
{
    if(i >= 0 && i < gridSize && j >= 0 && j < * gridColSize)
    {
        if(grid[i][j] == 1)
        {
            grid[i][j] = 2;
            return 1;
        }
    }
    return 0;
}

//使用广度优先搜索，对腐烂果子进行放进队列，出列后再处理新的，每遍历一次++一次时间
int orangesRotting(int** grid, int gridSize, int* gridColSize) 
{
    int day = 0;
    int queue[100][2];
    int head = 0;//队列头
    int tail = 0;//队列尾巴
    int isgoodnum = 0;
    //找全部坏果
    for(int i = 0; i < gridSize; i++)
    {
        for(int j = 0; j < *gridColSize; j++)
        {
            if(grid[i][j] == 2)
            {
                queue[head][0]= i;
                queue[head][1]= j;
                head++;
            }
            else if(grid[i][j] == 1)isgoodnum++;
        }
    }
    //把坏果上下左右遍历一遍，计算时间
    while(tail < head && isgoodnum > 0)
    {
        int count = head - tail;
        bool flag = false;
        //同一时间坏的，下一时间同时扩展腐烂的橘子
        for(int k = 0; k < count; k++)
        {
            int i = queue[tail][0];
            int j = queue[tail][1];
            if(orangesKuozhan(grid, gridSize, gridColSize, i + 1, j))
            {
                isgoodnum--;
                queue[head][0]= i + 1;
                queue[head][1]= j;
                head++;
                flag = true;
            }
            if(orangesKuozhan(grid, gridSize, gridColSize, i - 1, j))
            {
                isgoodnum--;
                queue[head][0]= i - 1;
                queue[head][1]= j;
                head++;
                flag = true;
            }
            if(orangesKuozhan(grid, gridSize, gridColSize, i, j + 1))
            {
                isgoodnum--;
                queue[head][0]= i;
                queue[head][1]= j + 1;
                head++;
                flag = true;
            }
            if(orangesKuozhan(grid, gridSize, gridColSize, i, j - 1))
            {
                isgoodnum--;
                queue[head][0]= i;
                queue[head][1]= j - 1;
                head++;
                flag = true;       
            }
            tail++;
        }
        if(flag)day++;

    }
    if(isgoodnum > 0)return -1;
    return day;
}

42、全排列（46回溯）

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

void huishu(int* nums, int numsSize, bool *use, int *path, int depth, int** res, int* returnSize)
{
    //depth会比numsSize多+1，相等的时候path数组刚刚存满，记录后return即可
    if(depth == numsSize)
    {
        for(int i = 0; i < numsSize; i++)
        {
            res[*returnSize][i] = path[i];
        }
        (*returnSize)++;
        return;
    }
    //每一个depth都会进行numsSize次操作，每个都选一遍
    for(int i = 0; i < numsSize; i++)
    {
        //找false,如果是ture跳过操作
        if(use[i]) continue;
        path[depth] = nums[i];
        use[i] = true;
        huishu(nums, numsSize, use, path, depth+1, res, returnSize);
        use[i] = false;
    }
}


int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) 
{
    * returnSize = 0;
    if(numsSize == 0)return 0;
    //计算排列数量
    int total = 1;
    for(int i =1; i <= numsSize; i++)
    {
        total *= i;
    }   
    //开辟返回数组空间，提前记录返回数组大小
    int** res = (int **)malloc(sizeof(int*)*total);
    * returnColumnSizes = (int *)malloc(sizeof(int)*total);
    for(int i = 0; i < total; i++)
    {
        res[i] = (int *)malloc(sizeof(int)*numsSize);
        (*returnColumnSizes)[i] = numsSize;
    }
    //使用过的数进行标记
    bool use[numsSize];
    for(int i=0; i<numsSize; i++) use[i] = false;
    //当前组合的数字，需要放入res的
    int path[numsSize];
    //记录递归层数
    int depth = 0;
    huishu(nums, numsSize, use, path, depth, res, returnSize);
    return res;
}