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

242题思路就是分别遍历两个单词,统计字母数量看看是否一致。

复制代码
 1 class Solution {
 2 public:
 3     bool isAnagram(string s, string t) {
 4         vector<int>tmp1(26);
 5         int len1 = s.size();
 6         int len2 = t.size();
 7         if(len1!=len2){
 8             return false;
 9         }
10         for(int i=0;i<len1;i++){
11             tmp1[s[i]-'a']++;
12             tmp1[t[i]-'a']--;
13         }
14         for(int k=0;k<26;k++){
15             if(tmp1[k]!=0){
16                 return false;
17             }
18         }
19         return true;
20     }
21 };
复制代码

349题的代码基本全部看不懂,贴一下原文代码吧

复制代码
 1 class Solution {
 2 public:
 3     vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
 4         unordered_set<int> result_set; // 存放结果,之所以用set是为了给结果集去重
 5         unordered_set<int> nums_set(nums1.begin(), nums1.end());
 6         for (int num : nums2) {
 7             // 发现nums2的元素 在nums_set里又出现过
 8             if (nums_set.find(num) != nums_set.end()) {
 9                 result_set.insert(num);
10             }
11         }
12         return vector<int>(result_set.begin(), result_set.end());
13     }
14 };
15 //这段代码是一个C++函数,属于一个名为 Solution 的类,其目的是找出两个整数数组 nums1 和 nums2 的交集。下面我将逐行解释这段代码:
16 
17 //unordered_set<int> nums_set(nums1.begin(), nums1.end());
18 //这行代码创建了一个名为 nums_set 的 unordered_set(无序集合)对象,它包含 nums1 数组中的所有元素。unordered_set 是一种容器,类似于 vector,但它不允许重复的元素,并且元素的迭代顺序是不确定的。nums1.begin() 和 nums1.end() 是迭代器,分别指向 nums1 数组的第一个元素和数组之后的位置(不包括数组的最后一个元素)。
19 
20 //for (int num : nums2) {
21 //这是一个基于范围的for循环(range-based for loop),是C++11引入的新特性。这种循环的语法糖使得遍历容器变得非常简洁。这里的意思是,对于 nums2 中的每个元素 num,执行花括号 {} 内的代码块。
22 
23 //if (nums_set.find(num) != nums_set.end()) {
24 //这行代码检查当前遍历到的元素 num 是否存在于 nums_set 中。nums_set.find(num) 会返回一个迭代器,指向 nums_set 中与 num 相等的元素。如果 num 不在 nums_set 中,find 函数将返回 nums_set.end(),这是一个指向 nums_set 结束之后的迭代器。
25 
26 //result_set.insert(num);
27 //如果 num 在 nums_set 中找到了,这行代码将 num 插入到另一个 unordered_set 对象 result_set 中。由于 unordered_set 不允许重复元素,如果 num 已经被插入,它不会被再次插入。
28 
29 //return vector<int>(result_set.begin(), result_set.end());
30 //这行代码将 result_set 转换成一个 vector(向量),并返回这个向量。vector<int>(result_set.begin(), result_set.end()) 是一种初始化 vector 的方式,它包含了 result_set 中的所有元素。
31 
32 //总的来说,这段代码的目的是找出两个数组的交集,并将结果存储在一个 vector 中返回。它使用了 unordered_set 来快速检查元素是否存在,并利用基于范围的for循环来简化代码。
复制代码
复制代码
 1 //只能算默写了一遍 完全是新学的规范
 2 //确实 没有限制单个元素数值的大小 不能用常规的数组来处理
 3 class Solution {
 4 public:
 5     vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
 6         unordered_set<int> ans;
 7         unordered_set<int> tmp(nums1.begin(),nums1.end());
 8         for (int num : nums2) {
 9             if (tmp.find(num) != tmp.end()) {
10                 ans.insert(num);
11             }
12         }
13         vector<int> res(ans.begin(),ans.end());
14         return res;
15     }
16 };
复制代码

202题我是常规求余数相加

复制代码
 1 class Solution {
 2 public:
 3     bool isHappy(int n) {
 4         unordered_set<int> tmp;
 5         int sum = 0;
 6         int num = n;
 7         int div;
 8         int remainder;
 9         while (num) {
10             while (num != 0) {
11                 div = num/10;
12                 remainder = num%10;
13                 sum += remainder*remainder;
14                 num = div;
15             }
16             if (sum == 1) {
17                 return true;
18             }
19             if (tmp.find(sum) == tmp.end()) {
20                 tmp.insert(sum);
21             } 
22             else {
23                 return false;;
24             }
25             num = sum;
26             sum = 0;
27         }  
28     return false;
29     }
30 };
复制代码

但是看题解有很有意思的快速求各位平方和的做法,还挺有趣的。

复制代码
1 int calculateNum(int n){
2         string str = to_string(n);
3         int res = 0;
4         for (char i:str){
5             int num = i - '0';
6             res = res + num*num;
7         }
8         return res;
9     }
复制代码

1题上来当然是暴力解法快速带走啊。

复制代码
 1 class Solution {
 2 public:
 3     vector<int> twoSum(vector<int>& nums, int target) {
 4         vector<int>ret(2);
 5         for (int i = 0; i < nums.size(); ++i) {
 6             for (int j = i + 1; j < nums.size(); ++j) {
 7                 if (nums[i] + nums[j] == target) {
 8                     ret[0] = i, ret[1] = j;
 9                     return ret;
10             }
11         }
12     }
13     return ret;
14     }
15 };
复制代码

好吧,步入正题,想想怎么用哈希表的知识解决。

复制代码
 1 //排序后 从小到大排序 然后左右开始遍历相加 这样时间复杂度是O(n) 排序的时间复杂度是O(logn) 相加也是比O(n^2)小的
 2 //但是这样的话,下标会乱,我需要一个东西,可以把下标和对应的数值存进去 就是你了underorder_map 甚至不需要排序 直接做减法 看看里面有没有对应的数值即可
 3 
 4 class Solution {
 5 public:
 6     vector<int> twoSum(vector<int>& nums, int target) {
 7         vector<int>ret(2);
 8         unordered_map<int,int> map;
 9         for (int i = 0; i < nums.size(); i++) {
10             if (map.find(target - nums[i]) != map.end()) {
11                 ret[0] = i;
12                 ret[1] = map[target - nums[i]];
13                 return ret;
14             }
15             map[nums[i]] = i;
16         }
17         return ret;
18     }
19 };
复制代码

 

posted @   清源风起时  阅读(693)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示