力扣_哈希表

217.存在重复元素

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

• 难度评价: ⭐
• 代码如下:

#include <unordered_map>

class Solution 
{
public:
    bool containsDuplicate(vector<int>& nums) 
    {
        std::unordered_map<int, int> um;
        for (std::vector<int>::iterator iter = nums.begin(); iter != nums.end(); iter++)
        {
            auto it = um.find((*iter)); //find找不到该键值对时会返回0，找到时返回该键的指针
            if (it == 0)
            {
                um.emplace((*iter), 1);
            } //找不到插入，初值为1
            else
            {
                return true;
            } //找到了说明该数不只一个，返回true
        }

        return false;
    }
};

• 详解： 

此处用了哈希表

优点：哈希表查找是很快的 ，时间复杂度接近O(1)。

缺点：建表比较耗费空间。

测试后还发现利用迭代器遍历vector比利用数组下标遍历vector性能要快，下面两个112ms是用数组遍历的，其他则是用迭代器

除了用哈希表，还可以排序vector数组，然后在遍历vector的过程中比较连续的两数是否相等 

代码如下：

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 1; i++)
        {
            if (nums[i] == nums[i+1])
                return true;
        }
        return false;
    }
};

本题中该解法耗时与哈希表相近，但空间占用要小10mb

633.平方数之和 

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。

示例 1：

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

示例 2：

输入：c = 3
输出：false

• 难度评价: ⭐⭐⭐
• 代码如下:

1. 第一版代码，简单枚举。代码如下：

#include <math.h>

class Solution 
{
public:
    bool IsNumInt(double num)
    {
        int intnum = (int)num;  //如3.3 -> 3
        if (intnum == num)  //若原本就是整数3，返回的就是true，若原本是3.3，返回的是false
            return true;
        else
            return false;
    }

    bool judgeSquareSum(int c)
    {
        if (c == 0)
            return true;

        int sqrt_c = ceil(sqrt(c));
        int square = 0;     //某数的平方值
        int remnant = 0;    //c - sqrt
        double sqrt_remnant;    //不double而是float的话这个数据会计算错误的结果

        for (int i = 0; i < sqrt_c; i++) // <=就会通不过力扣，但vs可以运行，可能是分母为0导致的？，但是<时C=0的情况就会有错误，所以C=0的情况单独在一开始分类讨论，这是力扣的问题，vs代码是没问题的，vs代码就是此代码<=，然后去掉对c=0的单独讨论
        {
            square = i * i;
            remnant = c - square; //c - 某数平方值，剩余值作为另一个整数的平方值
            sqrt_remnant = sqrt(double(remnant));

            //检查开方后的数是否为整数，是则返回true，否则进行下一轮循环
            if (IsNumInt(sqrt_remnant))
            {
                return true;
            }
        }

        return false;
    }
};

2.第二版代码，哈希表。代码如下：

#include <unordered_map>
class Solution 
{
public:
    bool judgeSquareSum(int c)
    {
        static std::unordered_map<int, long long> umap;    //反复查询时才能体现umap的优势，力扣每次做的是单次查询。此外，经测试，在函数内定义static umap可以达到class内全局的效果，并且力扣内测试的效率比定义class内全局变量的效率高10倍
        double c_sqrt = sqrt(c);
        if (c_sqrt == (int)c_sqrt && umap.find(c_sqrt) != umap.end()) //find找不到时返回最后一个元素的下一个元素
            return true;
        //检查 c_sqrt == (int)c_sqrt 的原因是umap.find(c_sqrt)时会将double自动换成int，先检查就不会出现这种问题 

        //找不到，从umap最高元素处开始增加数据
        int count = umap.size();
        for (; count <= c_sqrt; count++)
        {
            umap[count] = count * count;
        }
        count--;
        if (umap[count] == c)
            return true;

        double remant_sqrt = 0;
        for (count = 1; count < c_sqrt; count++)
        {
            remant_sqrt = sqrt(c - umap[count]);
            if (remant_sqrt == int(remant_sqrt) && umap.find(remant_sqrt) != umap.end())
            {
                return true;
            }
        }

        return false;
    }
};