8-7 leetcode

先判断数据是否合法

利用双层循环 对二维数组进行赋值

int** construct2DArray(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes){
    if (m * n != originalSize) { /* 不能转换的情况 */
        *returnSize = 0;
        return NULL;
    }

    int **res = (int**)malloc(sizeof(int*) * m);
    *returnColumnSizes = (int*)malloc(sizeof(int) * m);

    /* 生成二维数组m*n */
    for (int i = 0; i < m; i++) {
        res[i] = malloc(sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
        for (int j = 0; j < n; j++) {
            res[i][j] = original[i * n + j];
        }
    }
    *returnSize = m;
    return res;
}

使用双循环先对每一个元素进行数量统计【此题条件特殊，

1 <= nums.length <= 1000
1 <= sum(nums[i].length) <= 1000
1 <= nums[i][j] <= 1000；nums[i] 中的所有值 互不相同】

再次使用双循环将数量为numssize的数字挑出来【这个过程是升序添加的】

int* intersection(int** nums, int numsSize, int* numsColSize, int* returnSize){
    int array[1001] = {0};

    for(int i=0; i<numsSize; i++){
        for(int j=0; j<numsColSize[i]; j++){
            array[nums[i][j]] += 1;
        }
    }

    int idx = 0;
    int array2[1001] = {0}; 
    for(int i=1; i<=1000;i++){
        if(array[i] == numsSize){
            array2[idx++] = i;
        }
    }

    int* result = (int*)malloc( sizeof(int)* (idx) );

    for(int i=0; i<idx; i++){
        result[i] = array2[i];
    }

    *returnSize = idx;

    return result;
}

 遍历一遍loss，标记出生与死亡年份

再按年份升序遍历，当年出生累加去年人口减去死亡人口计算当下人口

int maximumPopulation(int** logs, int logsSize, int* logsColSize){
    int arr[2051];
    int max = 0;
    memset(arr, 0, sizeof(arr));
    for (int i = 0; i < logsSize; i++) {
        arr[logs[i][0]]++;
        arr[logs[i][1]]--;
    }
    for (int i = 1950; i <= 2050; i++) {
        arr[i] += arr[i - 1];
        if (arr[i] > arr[max]) {
            max = i;
        }
    }
    return max;
}

 

开辟一个结构相同的数组

双层循环遍历，直接计算当前坐标移动k后的位置并复制

int** shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes){
    *returnSize = gridSize;
    *returnColumnSizes = (int *)calloc(gridSize, sizeof(int));
    int i, j, n = *gridColSize, x, y;
    int **map = (int **)calloc(gridSize, sizeof(int *));
    for(i = 0; i < gridSize; i++) map[i] = (int *)calloc(n, sizeof(int));

    for(i = 0; i < gridSize; i++){
        (*returnColumnSizes)[i] = n;
        for(j = 0; j < n; j++){
            y = (j + k) % n;  
            x = (i + (j + k) / n) % gridSize; 
            map[x][y] = grid[i][j];
        }
    }

    return map;
}