代码随想录训练营Day05 | 242.有效的字母异位词-349. 两个数组的交集-202. 快乐数-1. 两数之和

242.有效的字母异位词

• 题目链接：242.有效的字母异位词
• 思路：字母异位词的思路在于统计字符出现的次数，二者字母相同，顺序不同，故分别统计两个字符串中字符出现的次数，只要字符出现次数相等，即是字母异位词。
• 代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size() != t.size())
            return false;
        int n = s.size();
        vector<int> cnts(26, 0);
        vector<int> cntt(26, 0);
        for(int i = 0; i < n; ++i) {
            cnts[s[i] - 'a']++;
            cntt[t[i] - 'a']++;
        }

        for(int i = 0; i < 26; ++i) {
            if(cnts[i] != cntt[i])
                return false;
        }

        return true;
    }
};

349. 两个数组的交集

• 题目链接：349. 两个数组的交集
• 思路：集合的运用，转成两个集合，求出二者的交集即可
• 代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans; 
        unordered_set<int> s2;
        unordered_set<int> s1(nums1.begin(), nums1.end());
        for(int x : nums2) {
            if(s1.count(x))
                s2.insert(x);
        }
        ans.assign(s2.begin(), s2.end());
        return ans;
    }
};

202. 快乐数

• 题目链接：202. 快乐数
• 思路：快乐数有一个数学理论知识，用快乐数的计算方法循环计算，如果为快乐数，最后结果为1，不为快乐数，求的数字会循环往复，比如116:
  
  1. 知道上述结论之后，第一种做法，使用哈希表存储已经计算过的值，如果在计算过程出为1，则为快乐数，如果计算结果出现了之前计算过的值，则不为快乐数；
  2. 使用双指针，看上述116的这个例子图，一个循环链表，本题就是判断这个链表有没有环，所以可以使用快慢指针，加一个是否为1的判断即可。
• 代码：

class Solution {
public:
	// 哈希表
	bool f1(int n) {
		unordered_set<int> rec;
        auto dfs = [&](auto&& dfs, int num) -> bool {
            int ans = 0;
            while(num > 0) {
                int last = num % 10;
                ans += last * last;
                num /= 10;
            }
            if(ans == 1)
                return true;
            if(rec.count(ans))
                return false;
            rec.insert(ans);
            
            return dfs(dfs, ans);
        };
	}
	// 双指针
	bool f2(int n) {
		auto get = [&](int num) -> int {
            int ans = 0;
            while(num > 0) {
                int last = num % 10;
                ans += last * last;
                num /= 10;
            }
            return ans;
        };
        
        int slow = n, fast = get(n);
        while(fast != 1 && slow != fast) {
            slow = get(slow);
            fast = get(get(fast));
        }
        return fast == 1;    
	}
	
    bool isHappy(int n) {
        return f2(n);
    }
};

1. 两数之和

• 题目链接：1. 两数之和
• 思路：
  1. 暴力解法：遍历数组中的每一对数，发现一对数和为target，返回true，没有返回false；
  2. 哈希表做法：一次遍历nums，键值对，每次遍历在哈希表中查找当前 nums[i]，如果存在返回{i, k}，不存在则将当前的存储{target- nums[i], i}存储在哈希表中，一次遍历即可。详细论述见，卡哥讲解，灵神讲解
• 代码：

class Solution {
public:
	
	// 暴力解法
	vector<int> f1(vector<int>& nums, int target) {
		for (int i = 0; ; i++) { // 枚举 i
            for (int j = i + 1; j < nums.size(); j++) { // 枚举 i 右边的 j
                if (nums[i] + nums[j] == target) { // 满足要求
                    return {i, j}; // 返回两个数的下标
                }
            }
        }
        // 题目保证有解，循环中一定会 return
        // 所以这里无需 return，毕竟代码不会执行到这里
	}
	
	// 哈希表做法
	vector<int> f1(vector<int>& nums, int target) {
        unordered_map<int, int> rec;
        int n = nums.size();
        for(int i = 0; i < n; ++i) {
            if(rec.find(nums[i]) != rec.end()) 
                return {i, rec[nums[i]]};
            rec[target-nums[i]] = i;
        }
        return {};
	}
    vector<int> twoSum(vector<int>& nums, int target) {
		return f2(vector<int>& nums, int target);
    }
};