算法训练day2：长度最小的子数组（滑动窗口），螺旋矩阵II（过程模拟），区间和、开发商购买土地（前缀和）-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_62725785/article/details/143392490

滑动窗口

顾名思义就是我们维护一个自定义的窗口，确定什么时候添加元素，什么时候删除元素，在数组上体现为head++和tail++。

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

非常典型的题目哈，这里用到的是滑动窗口的方法，滑动窗口保证了我们的算法时间复杂度只有On，非常的快速

稍微讲一下这道题怎么用滑动窗口，定义head和tail，head用来往窗口里面增加元素，tail表示窗口的最后一个元素，用来删除元素。head和tail两个指针每个最多只会移动n次，所以时间复杂度为On。

当窗口里面的元素和小于target时，我们选择head右移，继续添加元素

当窗口元素和大于target时，我们尝试tail右移，判断能否删除元素，并且记录最小的窗口大小。

代码如下：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int head=0,tail=0;
        int ans=Integer.MAX_VALUE;
        int count=0;
        while(head<nums.length){
            count+=nums[head];
            head++;
            if(count>=target){
                while(count-nums[tail]>=target){
                    count-=nums[tail];
                    tail++;
                }
                ans=Math.min(ans,head-tail); 
            }
        }
        if(count<target) return 0;
        return  ans;
    }
}

过程模拟

59. 螺旋矩阵 II

中等

相关企业

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

1 <= n <= 20

这道题目主要是考验边界值的处理，我们模拟这四个方向的遍历

代码如下

class Solution {
    public int[][] generateMatrix(int n) {
        int l = 0, r = n - 1, t = 0, b = n - 1;
        int[][] mat = new int[n][n];
        int num = 1, tar = n * n;
        while(num <= tar){
            for(int i = l; i <= r; i++) mat[t][i] = num++;
            t++;
            for(int i = t; i <= b; i++) mat[i][r] = num++;
            r--;
            for(int i = r; i >= l; i--) mat[b][i] = num++;
            b--;
            for(int i = b; i >= t; i--) mat[i][l] = num++;
            l++;
        }
        return mat;
    }
}

主要思路：

初始化一个 n×n 大小的矩阵 mat，然后模拟整个向内环绕的填入过程：

定义当前左右上下边界 l,r,t,b，初始值 num = 1，迭代终止值 tar = n * n；

当 num <= tar 时，始终按照从左到右从上到下从右到左从下到上填入顺序循环，每次填入后：
执行 num += 1：得到下一个需要填入的数字；

更新边界：例如从左到右填完后，上边界 t += 1，相当于上边界向内缩 1。

使用num <= tar而不是l < r || t < b作为迭代条件，是为了解决当n为奇数时，矩阵中心数字无法在迭代过程中被填充的问题。

最终返回 mat 即可。

如图所示

前缀和

区间和

题目描述

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

输入描述

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

输出描述

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

输入示例

输出示例

3
9

提示信息

数据范围：
0 < n <= 100000

题解思路：对从0到i计算前缀和，当要求i-j的区间和的时候，即为j处前缀和减去i处前缀和

代码如下


import java.util.Scanner;

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

        int n = scanner.nextInt();
        int[] vec = new int[n];
        int[] p = new int[n];

        int presum = 0;
        for (int i = 0; i < n; i++) {
            vec[i] = scanner.nextInt();
            presum += vec[i];
            p[i] = presum;
        }

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

            int sum;
            if (a == 0) {
                sum = p[b];
            } else {
                sum = p[b] - p[a - 1];
            }
            System.out.println(sum);
        }

        scanner.close();
    }
}

开发商购买土地

题目描述

在一个城市区域内，被划分成了n * m个连续的区块，每个区块都拥有不同的权值，代表着其土地价值。目前，有两家开发公司，A 公司和 B 公司，希望购买这个城市区域的土地。

现在，需要将这个城市区域的所有区块分配给 A 公司和 B 公司。

然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。

注意：区块不可再分。

输入描述

第一行输入两个正整数，代表 n 和 m。

接下来的 n 行，每行输出 m 个正整数。

输出描述

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

输入示例

输出示例

提示信息

如果将区域按照如下方式划分：

1 2 | 3
2 1 | 3
1 2 | 3

两个子区域内土地总价值之间的最小差距可以达到 0。

数据范围：

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

思路：这道题目也是选择用前缀和的方式，分别对行和列求前缀和，后期再遍历行和列，找出差值最小的答案。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int sum = 0;
        int[][] vec = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                vec[i][j] = scanner.nextInt();
                sum += vec[i][j];
            }
        }

        // 统计横向
        int[] horizontal = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                horizontal[i] += vec[i][j];
            }
        }

        // 统计纵向
        int[] vertical = new int[m];
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                vertical[j] += vec[i][j];
            }
        }

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

        int verticalCut = 0;
        for (int j = 0; j < m; j++) {
            verticalCut += vertical[j];
            result = Math.min(result, Math.abs(sum - 2 * verticalCut));
        }

        System.out.println(result);
        scanner.close();
    }
}