代码随想录算法训练营day2|209.长度最小的子数组、59.螺旋矩阵Ⅱ、区间和、开发商购买土地

1. 长度最小的子数组

题目链接：209.长度最小的数组
题目分析：https://leetcode.cn/problems/minimum-size-subarray-sum/solutions/305704/chang-du-zui-xiao-de-zi-shu-zu-by-leetcode-solutio/

定义两个指针 start 和 end 分别表示子数组（滑动窗口窗口）的开始位置和结束位置，维护变量 sum 存储子数组中的元素和（即从 nums[start] 到 nums[end] 的元素和）。

初始状态下，start 和 end 都指向下标 0，sum 的值为 0。

每一轮迭代，将 nums[end] 加到 sum，如果 sum≥s，则更新子数组的最小长度（此时子数组的长度是 end−start+1），然后将 nums[start] 从 sum 中减去并将 start 右移，直到 sum<s，在此过程中同样更新子数组的最小长度。在每一轮迭代的最后，将 end 右移。

主要思想：滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int l = 0; //左指针
        int r = 0; //右指针
        int len = Integer.MAX_VALUE;
        int sum = 0; //和
        for (; r < nums.length; r++) { //外层循环移动右指针
            sum += nums[r];
            while (sum >= target) { //内层循环移动左指针
                len = Math.min(len, r -l + 1); 
                sum -= nums[l]; 
                l++;
            }
        }
        if (len == Integer.MAX_VALUE) return 0;
        return len;
    }
}

2. 螺旋矩阵Ⅱ

题目链接：59. 螺旋矩阵||
文章详解：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] nums = new int[n][n];
        int startX = 0, startY = 0; //每一圈起始位置
        int offset = 1; //左闭右开的偏移位置
        int i, j; //行，列
        int loop = 1; //圈数
        int count = 1; //填入数字

        //n为偶数时循环n/2圈，n为奇数时循环n/2圈+一个中心点
        while (loop <= n/2) {
            //顶部
            for (j = startY; j < n - offset; j++) {
                nums[startX][j] = count;
                count++;
            }

            //右边
            for (i = startX; i < n - offset; i++) {
                nums[i][j] = count;
                count++;
            }

            //底部
            for (; j > offset - 1; j--) {
                nums[i][j] = count;
                count++;
            } 

            //左边
            for (; i > offset - 1; i--) {
                nums[i][j] = count;
                count++;
            }

            startX++;
            startY++;
            loop++;
            offset++;

        }
                    
        //n为奇数，单独设置中心点
        if (n % 2 == 1) {
            nums[n/2][n/2] = n * n;
        }   
        return nums;
    }

}

3. 区间和

题目描述

给定一个整数数组 Array，请计算该数组在每个指定区间内元素的总和。

输入描述

第一行输入为整数数组 Array 的长度 n，接下来 n 行，每行一个整数，表示数组的元素。随后的输入为需要计算总和的区间下标：a，b （b > = a），直至文件结束。

输出描述

输出每个指定区间内元素的总和。

输入示例

5
1
2
3
4
5
0 1
1 3

输出示例

3
9

提示信息

数据范围：0 < n <= 100000

练习输入输出

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] nums = new int[n];    //存放数字
        int[] sums = new int[n];    //存放0~i的区间和
        int sum = 0;

        for (int i = 0; i < n; i++) {
            nums[i] = scanner.nextInt();
            sum += nums[i];
            sums[i] = sum;
        }

        while (scanner.hasNextInt()) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int ans;

            if (a == 0) {
                ans = sums[b];
            } else {
                ans = sums[b] - sums[a - 1];
            }
            System.out.println(ans);
        }
        scanner.close();
    }
}

4. 开发商购买土地

题目描述

在一个城市区域内，被划分成了n * m个连续的区块，每个区块都拥有不同的权值，代表着其土地价值。目前，有两家开发公司，A 公司和 B 公司，希望购买这个城市区域的土地。
现在，需要将这个城市区域的所有区块分配给 A 公司和 B 公司。
然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。 为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。
注意：区块不可再分。

输入描述

第一行输入两个正整数，代表 n 和 m。
接下来的 n 行，每行输出 m 个正整数。

输出描述

请输出一个整数，代表两个子区域内土地总价值之间的最小差距。
输入示例
3 3
1 2 3
2 1 3
1 2 3
输出示例
0

提示信息

如果将区域按照如下方式划分：
1 2 | 3
2 1 | 3
1 2 | 3
两个子区域内土地总价值之间的最小差距可以达到 0。

数据范围：

1 <= n, m <= 100；
n 和 m 不同时为 1。

import java.util.Scanner;

public class solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int m = scanner.nextInt();

        int[][] nums = new int[n][m];    //存放权值
        int sum = 0; //所有权值和

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                nums[i][j] = scanner.nextInt();
                sum += nums[i][j];
            }
        }

        //统计横向
        int[] col = new int[n];  //每一行权值和
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                col[i] += nums[i][j];
            }
        }

        //统计纵向
        int[] row = new int[n];  //每一行权值和
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                row[j] += nums[i][j];
            }
        }

        int ans = Integer.MAX_VALUE;
        int colSum = 0;
        for (int i = 0; i<n; i++) {
            colSum += col[i];
            ans  = Math.min(ans, Math.abs(sum - colSum * 2));
        }

        int rowSum = 0;
        for (int i = 0; i<m; i++) {
            rowSum += row[i];
            ans  = Math.min(ans, Math.abs(sum - rowSum * 2));
        }

        System.out.println(ans);
    }
}