LeetcodeLearning Day 4

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量531 收藏 19
点赞数 23
文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48588585/article/details/141999365
版权

Day 4

Leetcode 283、移动零

移动零双指针方法

C++

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        // 设置一个变量，用来指向经过一系列操作后数组中所有为 0 元素的第一个位置上
        // 一开始默认在索引为 0 的位置
        int slow = 0;

        // 从头到尾遍历数组
        // 遍历完毕之后，slow 指向了一个为 0 的元素，或者如果数组中不存在 0 ，就和 fast 一样，超过了数组的范围
        for (int fast = 0; fast < nums.size(); fast++) {

            // 在遍历过程中，如果发现访问的元素是非 0 元素
            // 说明 slow 不在正确的位置上，需要向后移动，寻找合适的位置
            if (nums[fast] != 0) {

                // 这个时候，原先 slow 的值需要被 fast 的值覆盖
                nums[slow] = nums[fast];

                // slow 需要向后移动，寻找合适的位置
                slow++;

            }
        }

        // 接下来，只需要把 slow 极其后面所有的元素都设置为 0 就行
        for (int i = slow; i < nums.size(); i++) {

            // 都设置为 0 
            nums[i] = 0;

        }
    }
};

Python

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        # 设置一个变量，用来指向经过一系列操作后数组中所有为 0 元素的第一个位置上
        # 一开始默认在索引为 0 的位置
        slow = 0

        # 从头到尾遍历数组
        # 遍历完毕之后，slow 指向了一个为 0 的元素，或者如果数组中不存在 0 ，就和 fast 一样，超过了数组的范围
        for fast in range(len(nums)) : 

            # 在遍历过程中，如果发现访问的元素是非 0 元素
            # 说明 slow 不在正确的位置上，需要向后移动，寻找合适的位置
            if nums[fast] != 0:

                # 这个时候，原先 slow 的值需要被 fast 的值覆盖
                nums[slow] = nums[fast]

                # slow 需要向后移动，寻找合适的位置
                slow += 1

        # 接下来，只需要把 slow 极其后面所有的元素都设置为 0 就行
        for i in range(slow,len(nums)) : 

            # 都设置为 0 
            nums[i] = 0

复杂度分析

  • 时间复杂度：O(n)，其中 n 为序列长度。每个位置至多被遍历两次。
  • 空间复杂度：O(1)。只需要常数的空间存放若干变量。
LeetCode 485、最大连续 1 的个数

连续1的个数

Python

class Solution(object):
    def findMaxConsecutiveOnes(self, nums):

        # 最后一个 0 所在的索引位置
        lastZero = -1

        # 结果
        ans = 0

        # 从左到右访问数组 nums
        for i, num in enumerate(nums):

            # 1、当前元素为 0 ，更新 lastZero 
            if num == 0:
                lastZero = i
            
            # 2、否则说明当前元素为 1
            else:
                # 通过 lastZero 可以获取当前元素距离最前面的 1 的个数
                # 对比之前的 ans ，更新获取最大值
                ans = max(ans, i - lastZero)
        
        # 返回结果
        return ans
LeetCode 26、删除有序数组中的重复项

删除有序数组重复项

C++

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {

        // 指针 i 进行数组遍历
        int n = nums.size();

        // 指针 j 指向即将被赋值的位置
        int j = 0;

        // 开始对数组进行遍历
        for (int i = 0 ; i < n ; i++) {

            // 进行筛选
            if ( i == 0 ||  nums[i] != nums[i - 1]) {
                // 赋值
                nums[j] = nums[i];

                // j 移动
                j++;
            }
        }

        // 获取结果
        return j ;

    }
};

Python

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 指针 i 进行数组遍历
        n = len(nums)

        # 指针 j 指向即将被赋值的位置
        j = 0

        # 开始对数组进行遍历
        for  i in range(n): 

            # 进行筛选
            if  i == 0 or  nums[i] != nums[i - 1] : # 注意初始的情况
                # 赋值
                nums[j] = nums[i]

                # j 移动
                j += 1
 

        # 获取结果
        return j
LeetCode 80、删除有序数组中的重复项II

删除有序数组重复项2

Python

class Solution(object):
    def removeDuplicates(self, nums):

        # 指针 slow 指向即将被赋值的位置
        slow = 0

        # 开始对数组进行遍历
        for fast in range(len(nums)):

            # 进行筛选
            if slow < 2 or nums[fast] != nums[slow - 2]:
                # 赋值
                nums[slow] = nums[fast]
                # slow 移动
                slow += 1

        # 获取结果
        return slow
Recap: 排序算法

冒泡排序

冒泡排序

void bublleSort(vector<int> & nums)
{	
    int n = nums.size()
    // n个数，冒n-1个泡整个数组就有序了
    for(int i=0; i < n - 1; i++)
    {
        // 第i次排序需要对比n-1-i次（第0次冒泡，对比n-1次，后面每次冒泡都少比较一次，以此类推
        for(int j=0; j < n-i-1; j++)
        {
			if(nums[j] > nums[j+1])
            {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = nums[j];
            }
        }
    }
}

插入排序

插入排序

上面的做法在元素插入时经常要进行元素交换，因此在插入时可以采取下图的做法。

插入排序优化

for(int i=1; i < n-1; i++) // 第一个数当作已经是排好序的数组，将后面元素插入进来
{
    int key = a[i]; // 一会儿比a[i]小的元素会依次后移覆盖掉a[i]，因此先存起来
    // 每次插入，将遍历到的第i个元素依次和前面所有的已排序元素进行对比，直到找到比它小的元素为止并插入在该元素后面
    int j = i-1；
    while(j>=0 && a[j] > key)
    {
        // 只要j处元素比key大，就将其往后挪一位
        a[j+1] = a[j];
        j--;
    }
    a[j+1] = key;
}

选择排序

选择排序

for(int i=0; i < n-1; i++) // 总共循环n-1次，每次循环找到剩下未排序索引中最小的与已排序数组的最后一位进行交换
{
    int index = i; // 初始化本轮未排序数组中的最小元素下标，先假定为索引i，即本轮已排序数组的后一个位置
    for(int j=i+1; j < n; j++) // 从i+1开始，对后面的一共n-i-1个元素进行逐个对比查找最小值索引
    {
        if(nums[j] < nums[index])
        {
            index = j; // 如果找到较小的，更新最小值索引
        }
    }
    // 本轮遍历完，找到了未排序数组中的最小值，与nums[i]元素进行交换，加入已排序数组的最后一个元素
   	int temp = nums[i];
    nums[i] = nums[index];
    nums[index] = temp;
}
【模拟】小红书2023秋招提前批-小红的数组构造

python

n, k = map(int, input().split())
print((1 + n) * n * k // 2)

C++

#include <iostream>

using namespace std;

int main() {
    long n, k;
    cin >> n >> k;
    cout << (1 + n) * n * k / 2 << endl;
    return 0;
}
【模拟】科大讯飞2023非凡计划-将企鹅击落水中最小的力

python

n = int(input())
nums = list(map(int, input().split()))

# 寻找企鹅所在的方块，这里使用list的index方法也可以
for i, num in enumerate(nums):
    if num == -1:
        k = i
        break

# 分别计算子数组nums[:k]和nums[k+1:]中的最小值
# 并将两个最小值相加即为答案
print(min(nums[:k]) + min(nums[k+1:]))

C++

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    int k = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] == -1) {
            k = i;
            break;
        }
    }

    int leftMin = INT_MAX;
    for (int i = 0; i < k; i++) {
        leftMin = min(leftMin, nums[i]);
    }

    int rightMin = INT_MAX;
    for (int i = k + 1; i < n; i++) {
        rightMin = min(rightMin, nums[i]);
    }

    int answer = leftMin + rightMin;
    cout << answer << endl;
    return 0;
}
【模拟】美团2023秋招-小美走公路

Snipaste_2024-09-07_17-16-47

只有两条可能的路径，只需要计算顺时针和逆时针的两个结果进行比较即可。注意：终点也有可能在起点前面。

Python

n = int(input())
distance = list(map(int, input().split()))
x, y = map(int, input().split())


# 令x是索引在前的车站，y是索引在后的车站
# 另外，由于题目所给的车站索引是从1开始的
# 为了能够映射到数组distance中的索引
# 需要进行-1的操作
x, y = (x-1, y-1) if x < y else (y-1, x-1)
# 求两段距离
# 第一段为：从x顺时针走到y，对应的距离为sum(distance[x:y])
# 第二段为：从y顺时针走到x，对应的距离为sum(distance[:x]) + sum(distance[y:])
# 两者取较小值，即为答案
print(min(sum(distance[x:y]), sum(distance[:x]) + sum(distance[y:])))

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;

    vector<int> distance(n);

    for (int i = 0; i < n; i++) {
        cin >> distance[i];
    }

    int x, y;
    cin >> x >> y;

    if (x > y) {
        swap(x, y);
    }

    long long sum1 = 0;
    long long sum2 = 0;

    for (int i = x - 1; i < y - 1; i++) {
        sum1 += distance[i];
    }

    for (int i = 0; i < x - 1; i++) {
        sum2 += distance[i];
    }

    for (int i = y - 1; i < n; i++) {
        sum2 += distance[i];
    }

    cout << min(sum1, sum2) << endl;

    return 0;
}
【模拟】OPPO2023秋招提前批-小欧数组求和

Python

# 数组长度n，操作次数q
n, q = map(int, input().split())
# 初始数组nums
nums = list(map(int, input().split()))
# 计算初始数组nums的和
nums_sum = sum(nums)
# 储存q次修改的结果
ans = list()

# 循环q次，修改q次
for _ in range(q):
    # 修改的位置i和修改的内容x
    i, x = map(int, input().split())
    # 注意i输入表示的是第i个元素，将其改为索引需要-1
    i -= 1
    # 将nums[i]修改为x，则整体的和需要减少nums[i]，增加x
    nums_sum -= nums[i]
    nums_sum += x
    # 同时nums[i]被修改为x
    nums[i] = x
    # 将本次修改后的数组和nums_sum储存在ans中，方便后续按顺序输出
    ans.append(nums_sum)

for num in ans:
    print(num)

C++

#include <iostream>
using namespace std;

int main() {
    int n, q;
    cin >> n >> q;
    int nums[n];
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    int numsSum = 0;
    for (int i = 0; i < n; i++) {
        numsSum += nums[i];
    }
    int ans[q];

    for (int k = 0; k < q; k++) {
        int i, x;
        cin >> i >> x;
        i--;
        numsSum -= nums[i];
        numsSum += x;
        nums[i] = x;
        ans[k] = numsSum;
    }

    for (int i = 0; i < q; i++) {
        cout << ans[i] << endl;
    }

    return 0;
}

时空复杂度

  • 时间复杂度：O(N+q)。第一次计算nums的和的时间复杂度为O(N)，进行q次修改的时间复杂度为O(q)
  • 空间复杂度：O(1)。仅需若干常数变量。
【模拟】大疆2023秋招-农田中作物的最大产量
  1. 首先，读取输入，获取农田的行数和列数，然后创建一个二维数组来存储农田的作物产量。
  2. 接着，遍历二维数组，计算每行和每列的总产量，并累加到一个计数器中。
  3. 初始化一个变量，用于记录最大产量。
  4. 使用两层循环遍历每个位置，计算当前位置所在行和列的总产量，减去当前位置的作物产量，得到当前位置的最大产量。然后更新最大产量变量。
  5. 最后，将最大产量与总产量相加，得到最终结果，并输出。

Snipaste_2024-09-07_17-27-04

Python

# 输入二维数组的行数和列数
n, m = map(int, input().split())
# 输入二维数组
grid = list()
# 遍历n次，每次输入一行
for _ in range(n):
    grid.append(list(map(int, input().split())))

# 记录每一行的总和
row_sum = [sum(row) for row in grid]
# 记录每一列的总和
col_sum = [sum(col) for col in zip(*grid)]

# 初始化灌溉能够得到的增量inc为0
inc = 0
# 双重遍历二维矩阵
# 考虑以点(i,j)作为行列交点的情况
for i in range(n):
    for j in range(m):
        # 由于点(i,j)在行、列中被重复计算了两次
        # 因此需要减去一次grid[i][j]
        # 才能得到以点(i,j)作为交点的灌溉结果
        cur = row_sum[i] + col_sum[j] - grid[i][j]
        # 更新增量inc
        inc = max(inc, cur)

# 最终的答案为增量inc加上原二维数组中所有元素求和
print(inc + sum(row_sum))

C++

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;

    vector<vector<int>> grid(n, vector<int>(m));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }

    vector<int> rowSum(n, 0);
    vector<int> colSum(m, 0);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            rowSum[i] += grid[i][j];
            colSum[j] += grid[i][j];
        }
    }

    int inc = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int cur = rowSum[i] + colSum[j] - grid[i][j];
            inc = max(inc, cur);
        }
    }

    int totalSum = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            totalSum += grid[i][j];
        }
    }

    cout << inc + totalSum << endl;
    return 0;
}

时空复杂度

  • 时间复杂度：O(MN)。求和需要遍历整个二维矩阵
  • 空间复杂度：O(N+M)。row_sum和col_sum所占空间分别为O(N)和O(M)
总结
  • 记得acm模式不是return而是要打印出结果。
  • 快慢指针中，快指针遍历数组元素，慢指针用于隔断（初始化索引为-1）或指示即将赋值的元素（即指示下一个元素要挪到这个位置，通常初始化索引为0）
  • C++中，如果两个数都是整型，相除后会返回整数，舍弃小数部分，Python中，/默认返回浮点数（如6/2 == 3.0），进行整除应该使用//。
  • C++中，对于数据较大的一些题目，有时候变量需要考虑初始化为long或者long long类型。
  • Python中，nums[a:b]的切片为左闭右开区间，即[a,b)。
  • 对于数组中的索引相减：i-j，其大小可代表的元素数量如下图所示，其中下标的大小i表示该元素前面有i个元素。

Snipaste_2024-09-07_17-05-10

  • 对于题目给定的 第几个之类的字眼，要注意通常说的第i个元素所在的位置其下标为i-1，需要在原来基础上减一。
weaki233
关注
DAY ) mysql,MySQL last_day()函数
weixin_39824191的博客
03-12 2265
MySQL日期/时间last_day()函数last_day()是一个MySQL日期/时间函数，仅接受日期或datetime值。它用于获取指定日期的给定月份的最后一天。如果我们提供了无效的输入日期或日期时间，则它总是返回NULL值。句法以下是用于返回给定月份的最后日期的语法。参数说明日期：last_day函数仅接受一个参数，即date或datetime，以获取最后一天的日期。返回值此函数返回给定有...
安全基础：0-day漏洞
知行合一 止于至善
06-09 5832
这篇文章以阿里巴巴的FastJSon来介绍一下Zero-day（0-day）漏洞的基础常识。
雅礼集训Day4
DraZxlNDdt的博客
06-21 5169
今天炸的1p。。。。。 T1，给你100次询问，每次L，R，选[L,R]中的若干数进行异或，求有多少种结果，1
常见的0day攻击
heibaikong6的博客
03-17 6937
什么是0day 0day漏洞 通常是指还没有补丁的漏洞。也就是说官方还没有发现或者是发现了还没有开发出安全补丁的漏洞 0day攻击 利用0day漏洞进行的攻击，特点是利用简单，危害较大 常见0day——struts2 Struts2框架存在漏洞，平时说的存在struts2漏洞是指的远程命令/代码执行漏洞 影响范围 Struts2漏洞有很多，比较著名的几个远程命令/代码执行漏洞： ...
edusrc0day挖掘技巧
weixin_50464560的博客
05-05 1万+
网瑞达web资源管理系统0dayps： 作为在edusrc的小白，经常看见大师傅们的刷屏，我也很向往能像大师们一样有一次刷屏的机会，于是有了这一次的渗透之旅。思路：要想刷屏上分，就得找系统来挖掘，对于不会审计的我来说只有做一些黑盒测试（会审计大佬可以忽略这一点）首先我们利用fofa找一些与edu有关的系统​ 语法：“系统” && org=“China Education and Research Network Center”其中可以在前面加一些：阅卷系统、评分系统、直播系统、录播系统。（我
什么是0day漏洞？
DATA8866的博客
07-31 1万+
我们循序渐进的来解释这个词： 1、0day漏洞到底是什么呢？首先你要知道，它是某一类漏洞的统一叫法。 2、“0day”顾名思义就是很快，因为直译过来就是“不到一天的时间”，是不是很快。 3、稍微官方一点的说法是：指那些没有公开过，因而也没有补丁的漏洞，也就是通常所说的“未公开漏洞”。 4、再容易理解一些呢，就是：已经被发现(有可能未被公开)，而官方还没有相关补丁的漏洞。 5、把第4点直译...
Day.js 常用方法
热门推荐
halo1416的博客
04-21 5万+
前言 Day.js 是代替修改本地Date.prototype，Day.js对Date对象进行了封装，只需要调用Dayjs()即可。 相对moment.js而已，day.js的体积更小，只有2KB左右；moment.min.js 有16.7KB。 对应普通项目来说，对应时间的操作就只有那么几个（格式化、查询、计算），这些基于Day.js完全足够。并且Day.js的文档相对简单、清晰！ 该文章对比之前的moment.js的文章 Day.js官方文档   当前文章很多实例是以当前时间来处理的， 当前时间
微信 0day漏洞复现
星落的博客
04-19 1万+
目录 漏洞简介 影响版本 CS安装 漏洞复现 修复建议 漏洞简介 由于微信采用的是google内核，前些日子google爆出0day远程代码执行漏洞，但是需要关闭沙箱，而微信采用的是老版本google内核，默认关闭沙箱，因此只要微信用户点击恶意连接，可直接获取该PC电脑权限 影响版本 <=3.2.1.141(Windows系统) CS安装 下载地址链接：https://pan.baidu.com/s/19En7Pkz7HIeey82PUvEBwQ 提取码：fczw 在ka...
自学前端——day4
weixin_44584059的博客
01-23 8525
自学前端—day 4 CSS部分 margin 设置所有外边距属性。 margin:10px 5px 15px 20px; 上外边距是 10px 右外边距是 5px 下外边距是 15px 左外边距是 20px margin:10px; 所有 4 个外边距都是 10px 设置固定的背景图片 body { background-img:url('a.jpg'); background-repea...
php strtotime -1 day,PHP strtotime() 函数
weixin_35224206的博客
03-18 2928
strtotime() 函数将任何英文文本的日期时间描述解析为 Unix 时间戳。strtotime(time,now)time 规定要解析的时间字符串。now 用来计算返回值的时间戳。如果省略该参数，则使用当前时间。示例如下：便于比较学习，使用date将当时间戳与指定时间戳转换成系统时间。1.明天此时的时间戳strtotime("+1 day")[break]当前时间：echo date("Y-...
通达信day格式文件转换（含港股和基金等）
06-11
把通达信day文件转换为csv文件，包含上证、深证、港股。对于股票、基金、及港股的不同格式进行了处理。 用法：把stock.exe 复制到 vipdoc\sh\lday 或 vipdoc\sz\lday 或 vipdoc\ds\lday 下面，运行即可在当前目录下...
unity Time of Day 3.1.0 天气系统
08-09
unity制作动态天气系统的插件,可以模拟四季及24小时的天气变化
特斯拉+AI+DAY+PPT.pdf
09-16
特斯拉智能驾驶技术分享PPT
eq_data_30_day_m1.json
03-16
30天全球地震数据集
leetcode209:长度最小的子数组
D2510466299的博客
10-12 560
我们需要从一个包含。
leetcode链表（四）-删除链表的倒数第N个节点
weixin_40198632的博客
10-11 372
给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。
LeetCode | 704.二分查找
编程菜鸟的学习记录
10-12 244
LeetCode | 704.二分查找
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 124
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 349
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值