【leetcode题解C++】242.有效的字母异位词 and 202.快乐数 and 1.两数之和

242. 有效的字母异位词

给定两个字符串?s?和?t?，编写一个函数来判断?t?是否是?s?的字母异位词。

注意：若?s?和?t?中每个字符出现的次数都相同，则称?s?和?t?互为字母异位词。

示例?1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

思路：用一个数组来记录出现的次数即可。

代码实现：

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

202. 快乐数

编写一个算法来判断一个数?n?是不是快乐数。

「快乐数」?定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是?无限循环?但始终变不到 1。
• 如果这个过程?结果为?1，那么这个数就是快乐数。

如果?n?是?快乐数?就返回?true?；不是，则返回?false?。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

思路：注意到，判定是否无限循环是关键，如何？——哈希表。而对于对每一位的平方求和，写成一个单独的函数即可。

代码实现：

class Solution {
public:
    int getSum(int n) {
        int sum = 0;
        while(n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }

    bool isHappy(int n) {
        int sum = 0;
        unordered_set<int> record;
        while(1) {
            sum = getSum(n);
            if (sum == 1) {
                return 1;
            }
            if(record.find(sum) != record.end()) {
                return 0;
            }
            else record.insert(sum);
            n = sum;
        }
    }
};

1. 两数之和

给定一个整数数组?nums?和一个整数目标值?target，请你在该数组中找出?和为目标值?target? 的那?两个?整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

思路1：不能重复使用，首先想到哈希，注意到返回下标，那么存储键值对，用unordered_map。

代码实现1：

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

思路2：两层for循环，为每一位上的数字找有没有满足条件的匹配的数，在内层的for中用(j = i+1)作为for的条件（有点类似于冒泡排序或者冒泡排序的优化？），（下面的代码是用C语言完成的，也是作者第一次做力扣题时的解法，梦开始的地方...）。

代码实现2：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    for(int i = 0; i < numsSize; i++){
        for(int j = i+1; j < numsSize; j++){
            if(nums[i]+nums[j]==target){
                int* ret = malloc(sizeof(int)*2);
                ret[0] = i;
                ret[1] = j;
                *returnSize = 2;
                return ret;
            }
        }
    }
    return NULL;
}

?