代码随想录Day2

209.长度最小的子数组

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

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

子数组

$ [nums_l, nums_{l+1}, ..., nums_{r-1}, nums_r] $,并返回其长度。如果不存在符合条件的子数组,返回 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 <= 10^9^

1 <= nums.length <= 10^5^

1 <= nums[i] <= 10^5^


暴力

两个循环嵌套,分别枚举区间起始位置和结束位置,枚举出所有可能的区间;

很明显,复杂度\(O(n^2)\),TLE。

正解(滑动窗口)

我们想要将复杂度降到\(O(n)\),也就是只用一个循环;

如果用循环枚举区间起点,那就又回归到暴力了,所以要循环枚举区间终点;

可以把窗口想象成一只毛毛虫,如果肚子里数的总和<target就继续把下一个数吃掉;

反之则把最早吃掉的数吐出来;

过程中记录下每次窗口的长度,取min;

上代码(●'◡'●)
cpp 复制代码
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int ans=INT32_MAX,sum=0,len=0,i=0,n=nums.size();
        for(int j=0;j<n;j++){//循环枚举窗口
            sum+=nums[j];//吃
            while(sum>=target){//吐
                len=j-i+1;
                ans=min(len,ans);
                sum-=nums[i++];
            }
        }
        return ans==INT32_MAX?0:ans;//特判无解情况
    }
};

59.螺旋矩阵Ⅱ

给你一个正整数 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


正解(模拟)

一圈一圈的模拟,外面循环圈数,里面循环四条边;

代码:

cpp 复制代码
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));
        int mid = n / 2,cnt = 1,len = 1,sx = 0, sy = 0,loop = n / 2;
        int i,j;
        while (loop --) {
            i = sx;
            j = sy;
            for (j; j < n - len; j++) {
                res[i][j] = cnt++;
            }
            for (i; i < n - len; i++) {
                res[i][j] = cnt++;
            }
            for (; j > sy; j--) {
                res[i][j] = cnt++;
            }
            for (; i > sx; i--) {
                res[i][j] = cnt++;
            }
            sx++;
            sy++;
            len += 1;
        }
        if (n%2==1) {
            res[mid][mid] = cnt;
        }
        return res;
    }
};

区间和

题目描述

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

输入描述

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

输出描述

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

输入示例:

5
1
2
3
4
5
0 1
1 3

输出示例:

3
9

提示信息

数据范围:

0 < n <= 100000


正解(前缀和)

emm...

这道题基本就是前缀和模板题。。。

无需多言,上代码!

cpp 复制代码
#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, a, b;
    cin >> n;
    vector<int> vec(n);
    vector<int> p(n);
    int presum = 0;
    for (int i = 0; i < n; i++) {
        cin >> vec[i];
        presum += vec[i];
        p[i] = presum;//前缀和
    }

    while (cin >> a >> b) {
        int sum;
        if (a == 0) sum = p[b];
        else sum = p[b] - p[a - 1];//注意是a-1而不是a
        cout << sum << endl;
    }
}

开发商购买土地

【题目描述】

在一个城市区域内,被划分成了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。


正解(前缀和)

其实就是先把横向和纵向单列的都用前缀和统计出来,再求区间就容易了

代码如下:
cpp 复制代码
#include <iostream>
#include <vector>
#include <climits>

using namespace std;
int main () {
    int n, m;
    cin >> n >> m;
    int sum = 0;
    vector<vector<int>> vec(n, vector<int>(m, 0)) ;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> vec[i][j];
            sum += vec[i][j];
        }
    }
    // 统计横向
    vector<int> horizontal(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0 ; j < m; j++) {
            horizontal[i] += vec[i][j];
        }
    }
    // 统计纵向
    vector<int> vertical(m , 0);
    for (int j = 0; j < m; j++) {
        for (int i = 0 ; i < n; i++) {
            vertical[j] += vec[i][j];
        }
    }
    int result = INT_MAX;
    int horizontalCut = 0;
    for (int i = 0 ; i < n; i++) {
        horizontalCut += horizontal[i];
        result = min(result, abs(sum - horizontalCut - horizontalCut));
    }
    int verticalCut = 0;
    for (int j = 0; j < m; j++) {
        verticalCut += vertical[j];
        result = min(result, abs(sum - verticalCut - verticalCut));
    }
    cout << result << endl;
}

时间复杂度\(O(n^2)\);

虽然看起来不快,但暴力的复杂度要达到\(O(n^3)\),这样一对比,还算蛮快的了。

写博不易,请大佬点赞支持一下8~