leetcode刷题笔记

刷题方法：找题目，想思路，做题目，优化到beats100%

数组

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

• 暴力解法：两层循环，i从0-n-2，j从i+1到n-1，如果nums[i]+nums[j]=target那么i和j就是要找的下标
• 利用哈希表数据结构：一层循环，i从0-n-1，使用哈希表，看target-nums[i]的值是否在哈希表中，如果在则返回i和哈希表中key==target-nums[i]的value值；如果不在就将key=nums[i],value=i存入哈希表中（以便之后被找到）

// 哈希表用map来实现
# include<map>
map<int, int>findtag;
int flag = findtag.count(tag);  //返回key=tag的元素的个数
if (flag == 0)
   	{
   		findtag[nums[i]]=i;  //插入元素，key=nums[i],value=i
   	}

寻找两个有序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 找中位数显然需要排序，对于两个有序数组排序采用归并排序。
  归并排序思想比较简单。比较两个数组中最大的数，大的那个出来放到新的数组中，这样新数组就是两个旧数组合并下来之后从大到小的顺序。
• 找中位数没必要将两个数组完整排序，共有n个元素，只需要找到n/2+1个元素，不论奇数偶数都够用了。
• 注意易错的地方时防止数组下标越界（出现-1的情况），也就是归并排序过程中不仅要考虑大小关系，还要考虑原来的数组此时是否已经为空了。

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) 
{
	int n = nums1.size() + nums2.size();
	vector<int>allnum;
	for (int i = 0; i <= n/2; i++)
	{
		if (nums1.size() == 0)
		{
			allnum.push_back(nums2[nums2.size() - 1]);
			nums2.pop_back();
		}
		else
		{
			if (nums2.size() == 0)
			{
				allnum.push_back(nums1[nums1.size() - 1]);
				nums1.pop_back();
			}
			else
			{
				if (nums1[nums1.size() - 1] < nums2[nums2.size() - 1])
				{
					allnum.push_back(nums2[nums2.size() - 1]);
					nums2.pop_back();
				}
				else
				{
					allnum.push_back(nums1[nums1.size() - 1]);
					nums1.pop_back();
				}
			}
		}	
	}
	if (n % 2 == 0)return(allnum[allnum.size()-1]+ allnum[allnum.size() - 2])/2.0;
	else return allnum[allnum.size() - 1];
}

盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
示例 3：
输入：height = [4,3,2,1,4]
输出：16
示例 4：
输入：height = [1,2,1]
输出：2
提示：
n == height.length
2 <= n <= 105
0 <= height[i] <= 104
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/container-with-most-water
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 暴力解法，枚举所有的情况，两次循环，结果超时。
• 双指针解法，思路是先令两个指针分别指向数组头尾，之后每次将指向数字较小的指针向中间移动直到两指针指向同一个元素.同时每次循环的时候都计算此次的面积，用max存储最大的面积。（正确性证明：每次指针移动相当于将一个数字排除在外，那个数字不可能作为容器的边缘）

//双指针解法代码
int maxArea(vector<int>& height) {
	int d = height.size() - 1;
	int max = 0;
	vector<int>::iterator itl = height.begin();
	vector<int>::iterator itr = height.end() - 1;
	while (itr != itl)
	{
		//计算此次循环对应的面积，存储最大面积
		int nowarea = d * ((*itl < *itr) ? *itl : *itr);
		max = (nowarea > max) ? nowarea : max;
		//更新下一次循环的底和高（移动指针）
		d--;
		if (*itl > *itr)itr--;
		else itl++;
	}
	return max;
}

3sum问题

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
提示：
0 <= nums.length <= 3000
-105 <= nums[i] <= 105
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 想到了之前做的2sum问题，所以试图遍历n个数中的前n-2个，剩余的部分当作2sum问题求解。尝试之后发现这样的问题是无法排除重复解。这也是整个问题的难点。
• 正确思路是：首先排序，遍历n个数中的前n-2个，遇到重复的跳过，剩余的部分用双指针处理。
• 排序+双指针具体实现比较麻烦，还有些思路不太清楚，最终AC了，先保存代码之后思考优化方法。

vector<vector<int>> threeSum(vector<int>& nums) {
	sort(nums.begin(), nums.end());
	vector < vector<int>> _3sum;
	int n = nums.size();
	map<int, int>start;
	for (int i = 0; i < n - 2; i++)
	{
		if (start.count(nums[i]) != 0)continue;
		start[nums[i]] = i;
		int _2sum = -nums[i];
		//2_sum问题如何避免重复？用双指针
		vector<int>::iterator itl = nums.begin()+i+1;
		vector<int>::iterator itr = nums.end()-1;
		while (itl<itr)
		{
			if (*itl == *itr)
			{
				if (*itl * 2 != _2sum)break;
				else
				{
					goto HERE;
				}
			}
			if (*itl + *itr > _2sum)
			{
				while (*itr == *(itr - 1))itr--;//先将重复的排除
				itr--;
			}
			else
			{
				if (*itl + *itr < _2sum)
				{
					while (*itl == *(itl + 1))itl++;
					itl++;
				}
				else
				{
			HERE:		vector<int>sum;
					sum.push_back(nums[i]);
					sum.push_back(*itl);
					sum.push_back(*itr);
					_3sum.push_back(sum);
					if (*itl == *itr)break;
					while (*itl == *(itl + 1))itl++;
					itl++;
				}
			}
		}
	}
	return _3sum;
}