力扣刷题总结 -- 数组11

31. 错误的集合（简单）

题目要求：

集合s包含从1到n的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合丢失了一个数字并且有一个数字重复。

给定一个数组 nums 代表了集合 S 发生错误后的结果。

请找出重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

题目解答：

利用Hashmap

#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>


class Solution
{
public:
	vector<int> findErrorNums(vector<int>& nums)
	{
		vector<int> errorNums(2);  // 接收结果
		int n = nums.size();
		unordered_map<int, int> mp;

		for (auto& num : nums)
		{
			mp[num]++;  // 记录每个元素的出现次数
		}

		for (int i = 1; i <= n; i++)
		{
			int count = mp[i];
			if (count == 2)  // 当有一个元素的出现次数为2时，说明重复出现
			{
				errorNums[0] = i;
			}
			else if (count == 0)  // 当有一个元素的出现次数为0时，说明丢失了
			{
				errorNums[1] = i;
			}
		}

		return errorNums;
	}

};


int main()
{
	vector<int> nums = { 1,2,2,4 };

	cout << "原数组为：" << endl;
	for (auto& num : nums)
	{
		cout << num << ", ";
	}
	cout << endl;

	Solution s;
	vector<int> res = s.findErrorNums(nums);

	cout << "重复出现的数字为：" << res[0] << ", " << "丢失的整数为：" << res[1] << endl;



	system("pause");
	return 0;
}

32. 图片平滑器（重要）（简单）

题目要求：

图像平滑器是大小为 3 x 3 的过滤器，用于对图像的每个单元格平滑处理，平滑处理后该单元格的值为该单元格自身及其周围的 8 个单元格的平均灰度。

每个单元格的平均灰度定义为：该单元格自身及其周围的 8 个单元格的平均值，结果需向下取整。

如果一个单元格周围存在单元格缺失的情况，则计算平均灰度时不考虑缺失的单元格（即，需要计算红色平滑器中 4 个单元格的平均值）。

题目解答：

#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>


class Solution
{
public:
	vector<vector<int>> averageFilter(vector<vector<int>>& img)
	{
		int m = img.size(), n = img[0].size();  // 获得图像的行数和列数
		vector<vector<int>> ret(m, vector<int>(n));  // 创建二维数组，大小和原图相同

		// 遍历ret的每个元素
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				int num = 0, sum = 0;
				for (int x = i - 1; x <= i + 1; x++)
				{
					for (int y = j - 1; y <= j + 1; y++)
					{
						if (x >= 0 && x < m && y >= 0 && y < n)  // 计算每个单元格及其周围8个单元格的元素和
						{
							num++;
							sum += img[x][y];
						}
					}
				}

				ret[i][j] = sum / num;  // 计算每个单元格平滑后的值
			}
		}

		return ret;
	}

};


int main()
{
	vector<vector<int>> img = { {100,200,100}, {200,50,200}, {100,200,100} };
	Solution s;
	vector<vector<int>> res = s.averageFilter(img);

	cout << "平滑前的图像：" << endl;
	for (vector<vector<int>>::iterator it = img.begin(); it != img.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << ", ";
		}
		cout << endl;
	}
	cout << endl;

	cout << "平滑后的图像：" << endl;
	for (vector<vector<int>>::iterator it = res.begin(); it != res.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << ", ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

33. 最长连续递增序列（简单）

题目要求：

给定一个未经排序的整数数组，找到最长且连续递增的子序列，并返回该序列的长度。

连续递增的子序列可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

题目解答：

#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>


class Solution
{
public:
	int findLengthOfLCIS(vector<int>& nums)
	{
		int ans = 0;
		int n = nums.size();
		int start = 0;  // 存放递增子序列的起点

		for (int i = 0; i < n; i++)
		{
			if (i > 0 && nums[i] <= nums[i - 1])  // 如果该元素小于等于其上一个元素，重置起点
			{
				start = i;
			}

			ans = max(ans, i - start + 1);  // 不断更新递增子序列的长度
		}

		return ans;
	}

};


int main()
{
	vector<int> nums = { 1,3,5,4,7 };

	Solution s;
	int ans = s.findLengthOfLCIS(nums);

	cout << "最长连续递增子序列的长度为：" << ans << endl;

	system("pause");
	return 0;
}