程式碼隨想錄演算法訓練營第六天| 242. 有效的字母異位詞、349.兩個陣列的交集、202.快樂數、1.兩數之和

242題思路就是分別遍歷兩個單詞，統計字母數量看看是否一致。

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

349題的程式碼基本全部看不懂，貼一下原文程式碼吧

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放結果，之所以用set是為了給結果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 發現nums2的元素 在nums_set裡又出現過
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};
//這段程式碼是一個C++函式，屬於一個名為 Solution 的類，其目的是找出兩個整數陣列 nums1 和 nums2 的交集。下面我將逐行解釋這段程式碼：

//unordered_set<int> nums_set(nums1.begin(), nums1.end());
//這行程式碼建立了一個名為 nums_set 的 unordered_set（無序集合）物件，它包含 nums1 陣列中的所有元素。unordered_set 是一種容器，類似於 vector，但它不允許重複的元素，並且元素的迭代順序是不確定的。nums1.begin() 和 nums1.end() 是迭代器，分別指向 nums1 陣列的第一個元素和陣列之後的位置（不包括陣列的最後一個元素）。

//for (int num : nums2) {
//這是一個基於範圍的for迴圈（range-based for loop），是C++11引入的新特性。這種迴圈的語法糖使得遍歷容器變得非常簡潔。這裡的意思是，對於 nums2 中的每個元素 num，執行花括號 {} 內的程式碼塊。

//if (nums_set.find(num) != nums_set.end()) {
//這行程式碼檢查當前遍歷到的元素 num 是否存在於 nums_set 中。nums_set.find(num) 會返回一個迭代器，指向 nums_set 中與 num 相等的元素。如果 num 不在 nums_set 中，find 函式將返回 nums_set.end()，這是一個指向 nums_set 結束之後的迭代器。

//result_set.insert(num);
//如果 num 在 nums_set 中找到了，這行程式碼將 num 插入到另一個 unordered_set 物件 result_set 中。由於 unordered_set 不允許重複元素，如果 num 已經被插入，它不會被再次插入。

//return vector<int>(result_set.begin(), result_set.end());
//這行程式碼將 result_set 轉換成一個 vector（向量），並返回這個向量。vector<int>(result_set.begin(), result_set.end()) 是一種初始化 vector 的方式，它包含了 result_set 中的所有元素。

//總的來說，這段程式碼的目的是找出兩個陣列的交集，並將結果儲存在一個 vector 中返回。它使用了 unordered_set 來快速檢查元素是否存在，並利用基於範圍的for迴圈來簡化程式碼。

//只能算默寫了一遍 完全是新學的規範
//確實 沒有限制單個元素數值的大小 不能用常規的陣列來處理
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> ans;
        unordered_set<int> tmp(nums1.begin(),nums1.end());
        for (int num : nums2) {
            if (tmp.find(num) != tmp.end()) {
                ans.insert(num);
            }
        }
        vector<int> res(ans.begin(),ans.end());
        return res;
    }
};

202題我是常規求餘數相加

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> tmp;
        int sum = 0;
        int num = n;
        int div;
        int remainder;
        while (num) {
            while (num != 0) {
                div = num/10;
                remainder = num%10;
                sum += remainder*remainder;
                num = div;
            }
            if (sum == 1) {
                return true;
            }
            if (tmp.find(sum) == tmp.end()) {
                tmp.insert(sum);
            } 
            else {
                return false;;
            }
            num = sum;
            sum = 0;
        }  
    return false;
    }
};

但是看題解有很有意思的快速求各位平方和的做法，還挺有趣的。

int calculateNum(int n){
        string str = to_string(n);
        int res = 0;
        for (char i:str){
            int num = i - '0';
            res = res + num*num;
        }
        return res;
    }

1題上來當然是暴力解法快速帶走啊。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>ret(2);
        for (int i = 0; i < nums.size(); ++i) {
            for (int j = i + 1; j < nums.size(); ++j) {
                if (nums[i] + nums[j] == target) {
                    ret[0] = i, ret[1] = j;
                    return ret;
            }
        }
    }
    return ret;
    }
};

好吧，步入正題，想想怎麼用雜湊表的知識解決。

//排序後 從小到大排序 然後左右開始遍歷相加 這樣時間複雜度是O(n) 排序的時間複雜度是O(logn) 相加也是比O(n^2)小的
//但是這樣的話，下標會亂，我需要一個東西，可以把下標和對應的數值存進去 就是你了underorder_map 甚至不需要排序 直接做減法 看看裡面有沒有對應的數值即可

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>ret(2);
        unordered_map<int,int> map;
        for (int i = 0; i < nums.size(); i++) {
            if (map.find(target - nums[i]) != map.end()) {
                ret[0] = i;
                ret[1] = map[target - nums[i]];
                return ret;
            }
            map[nums[i]] = i;
        }
        return ret;
    }
};