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

242. 有效的字母异位词

用数组作为哈希表，速度更快；直接用s[i] - 'a'，不用记忆字符的ASCII码

class Solution {
public:
    bool isAnagram(string s, string t) {
        int table[26] = {0};
        for (int i = 0; i < s.length(); i++){
            table[s[i]-'a']++;
        }
        for (int i = 0; i < t.length(); i++){
            table[t[i]-'a']--;
        }
        for (int i = 0; i < 26; i++){
            if(table[i] != 0 ) return false;
        }        
        return true;
    }
};

349. 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set(nums1.begin(), nums1.end());
        vector<int> result;
        for(auto iter : nums2){
            if(set.find(iter) != set.end()){
                set.erase(iter);
                result.push_back(iter);
            }
        }
        return result;
    }
};

202. 快乐数

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

1. 两数之和

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

1012. 至少有 1 位重复的数字

数位dp，有点难度

class Solution {
public:
    int numDupDigitsAtMostN(int n) {
        auto s = to_string(n);
        int m = s.length(), dp[m][1 << 10];
        memset(dp, -1, sizeof(dp)); // -1 表示没有计算过
        function<int(int, int, bool, bool)> f = [&](int i, int mask, bool is_limit, bool is_num) -> int {
            if (i == m)
                return is_num; // is_num 为 true 表示得到了一个合法数字
            if (!is_limit && is_num && dp[i][mask] != -1)
                return dp[i][mask];
            int res = 0;
            if (!is_num) // 可以跳过当前数位
                res = f(i + 1, mask, false, false);
            int up = is_limit ? s[i] - '0' : 9; // 如果前面填的数字都和 n 的一样，那么这一位至多填数字 s[i]（否则就超过 n 啦）
            for (int d = 1 - is_num; d <= up; ++d) // 枚举要填入的数字 d
                if ((mask >> d & 1) == 0) // d 不在 mask 中
                    res += f(i + 1, mask | (1 << d), is_limit && d == up, true);
            if (!is_limit && is_num)
                dp[i][mask] = res;
            return res;
        };
        return n - f(0, 0, true, false);
    }
};