【力扣刷题笔记】初级算法

初级算法

数组

1.删除排序数组中的重复项

题目

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2gy9m/

我的解法

速度太慢！

class Solution { 
public:    
	int removeDuplicates(vector<int>& nums) {
    	for (vector<int>::iterator itor = nums.begin(); itor != nums.end(); )        
        {
        	int x,y;
            x=*itor;
            ++itor;
            if(itor!=nums.end())
            	y=*itor;
            else
            	break;
            if(x==y)
            {
            	nums.erase(itor);
                itor--;
            }
        }
        return nums.size();
        }
};

官解

双指针

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
};

或者：

//双指针解决
public int removeDuplicates(int[] A) {
    //边界条件判断
    if (A == null || A.length == 0)
        return 0;
    int left = 0;
    for (int right = 1; right < A.length; right++)
        //如果左指针和右指针指向的值一样，说明有重复的，
        //这个时候，左指针不动，右指针继续往右移。如果他俩
        //指向的值不一样就把右指针指向的值往前挪
        if (A[left] != A[right])
            A[++left] = A[right];
    return ++left;
}

2.买卖股票的最佳时机 II

题目

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
	 总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2zsx1/

我的解法

贪心

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        int ans=0;
        for(int i=0;i<n-1;i++)
        {
            if(prices[i+1]-prices[i]>0)
            {
                ans+=prices[i+1]-prices[i];
            }
        }
        return ans;
    }
};

官解

DP（可延伸，学习思路）

定义dp[i][0]表示第i+1天交易完之后手里没有股票的最大利润，dp[i][1]表示第i+1天交易完之后手里持有股票的最大利润。

当天交易完之后手里没有股票可能有两种情况，一种是当天没有进行任何交易，又因为当天手里没有股票，所以当天没有股票的利润只能取前一天手里没有股票的利润。一种是把当天手里的股票给卖了，既然能卖，说明手里是有股票的，所以这个时候当天没有股票的利润要取前一天手里有股票的利润加上当天股票能卖的价格。这两种情况我们取利润最大的即可，所以可以得到

dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);

当天交易完之后手里持有股票也有两种情况，一种是当天没有任何交易，又因为当天手里持有股票，所以当天手里持有的股票其实前一天就已经持有了。还一种是当天买入了股票，当天能买股票，说明前一天手里肯定是没有股票的，我们取这两者的最大值，所以可以得到

dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);

动态规划的递推公式有了，那么边界条件是什么，就是第一天

如果买入：dp[0][1]=-prices[0];

如果没买：dp[0][0]=0;

3.旋转数组

题目

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

1 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

进阶：

尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2skh7/

我的解法

左右部分交换

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n=nums.size();
        k%=n;
        reverse(nums,0,n-k-1);
        reverse(nums,n-k,n-1);
        reverse(nums,0,n-1);
    }

    void reverse(vector<int>& nums,int l,int r)
    {
        while(l<r)
            swap(nums[l++],nums[r--]);
    }
};

官解

1.同我的解法

2.环状替换

我们从位置 $0$ 开始，最初令$\text{temp}=\text{nums}[0]$。根据规则，位置 $0$ 的元素会放至 $(0+k)\mathrm{mod}n(0+k)modn$ 的位置，令$x=(0+k)modn$，此时交换 $temp$ 和 $nums[x]$，完成位置 $x$ 的更新。然后，我们考察位置 $x$，并交换 $temp$ 和 $\text{nums}[(x+k)\mathrm{mod}n]$，从而完成下一个位置的更新。不断进行上述过程，直至回到初始位置 $0$。

容易发现，当回到初始位置 $0$ 时，有些数字可能还没有遍历到，此时我们应该从下一个数字开始重复的过程，可是这个时候怎么才算遍历结束呢？我们不妨先考虑这样一个问题：从 00 开始不断遍历，最终回到起点 $0$ 的过程中，我们遍历了多少个元素？

由于最终回到了起点，故该过程恰好走了整数数量的圈，不妨设为 a 圈；再设该过程总共遍历了 b 个元素。因此，我们有 $an=bk$，即 anan 一定为n,k 的公倍数。又因为我们在第一次回到起点时就结束，因此 a 要尽可能小，故 $a_n$ 就是 n,k 的最小公倍数 $\text{lcm}(n,k)$，因此 b就为 $lcm(n,k)/k$。

这说明单次遍历会访问到 $\text{lcm}(n,k)/k$ 个元素。为了访问到所有的元素，我们需要进行遍历的次数为$\frac{\text{n}}{\text{lcm}(n,k)/k}=\frac{\text{nk}}{\text{lcm}(n,k)}=\text{gcd}(n,k)$

一些思考

1.贝祖定理:若a,b是整数,且gcd(a,b)=d，那么对于任意的整数x,y,ax+by都一定是d的倍数，特别地，一定存在整数x,y，使ax+by=d成立。(d是ax+by能到达的最小正值)

2.单次遍历到的点之间一定是等间隔的(反证法可以证明)

4.存在重复元素

题目

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

输入：nums = [1,2,3,1]
输出：true

示例 2：

输入：nums = [1,2,3,4]
输出：false

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true

提示：

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

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x248f5/

我的解法

利用哈希表作重复性检查

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> set;
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            pair<unordered_set<int>::iterator, bool> ret=set.insert(nums[i]);
            if(!ret.second)
            {
                return true;
            }
        }
        return false;
    }
};

官解

同我的解法

5.只出现一次的数字

题目

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x21ib6/

我的解法

利用异或(数电实验头歌平台做过类似签到题)

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans=0;
        for(auto x:nums)
        {
            ans=ans^x;
        }
        return ans;
    }
};

官解

同我的解法

6.两个数组的交集 II

题目

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

进阶：

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2y0c2/

我的解法

排序 + 双指针

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int p1=0,p2=0;
        vector<int> ans;
        while(p1<nums1.size()&&p2<nums2.size())
        {
            if(nums1[p1]<nums2[p2])
            {
                p1++;
            }
            else if(nums1[p1]>nums2[p2])
            {
                p2++;
            }
            else
            {
                ans.push_back(nums1[p1]);
                p1++;p2++;
            }
        }
        return ans;
    }
};

官解

1.哈希表

class Solution {
   
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
   
        if(nums1