LeetCode202.快乐数

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

提示：

• 1 <= n <= 231 - 1

解法

方法一：unordered_set + 递归

可以使用递归的方法。首先，创建一个unordered_set（无序集合）来存储出现过的数，以便检测是否出现无限循环。然后，编写一个递归函数isHappy，该函数接受一个整数n作为参数，判断n是否为快乐数。

在isHappy函数中，首先检查n是否等于1，如果是，则返回true，因为已经得到了快乐数。接下来，检查unordered_set中是否已经存在n，如果存在，则说明出现了无限循环，返回false。否则，将n插入到unordered_set中，并计算n每个位置上数字的平方和，并将结果赋值给sum。然后，将sum作为参数递归调用isHappy函数，继续判断sum是否为快乐数。

最终，当输入的n为快乐数时，isHappy函数会递归调用直到n变为1，返回true；当输入的n不是快乐数时，会在无限循环中检测到重复的数，返回false。

下面两种都可以，我的讲解主要是依据第二种代码。

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

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

时间复杂度分析：

• 在最坏情况下，函数可能会进入无限循环，因此时间复杂度没有上限。
• 在每次递归调用中，对于给定的数n，需要计算n的每个位上数字的平方和，这需要对n进行取余和除法操作。这两个操作的时间复杂度都是O(log n)，其中n是输入的数。
• 由于递归调用是基于输入n的大小而减小的，所以可以认为递归的总时间复杂度是O(log n)。

空间复杂度分析：

• 函数中使用了一个unordered_set来存储出现过的数，以检测是否进入无限循环。在最坏情况下，如果输入的数一直不变，unordered_set可能会无限增长。

• 在递归调用过程中，unordered_set会保存所有不同的n值，因此空间复杂度取决于递归调用的深度，即O(log n)。

• 除此之外，还需要考虑函数调用栈的空间，由于递归调用的最大深度是O(log n)，所以函数调用栈的空间复杂度也是O(log n)。

  综上所述，该函数的时间复杂度为O(log n)，空间复杂度为O(log n)

方法二：unordered_set+迭代

添加了一个新的函数getSum，用于计算给定数的每个位上数字的平方和。在getSum函数中，使用一个循环，每次迭代时将n的个位数取出，并将其平方加到sum上，然后将n除以10，以便继续处理下一位。最后返回计算得到的sum。

在主函数isHappy中，使用一个unordered_set来存储出现过的和sum，用于判断是否进入无限循环。通过一个无限循环的while循环，在每次循环中，首先调用getSum函数计算当前数n的平方和sum。然后进行以下判断：

• 如果sum等于1，说明已经得到了快乐数，返回true。
• 如果set中已经存在sum，说明进入了无限循环，返回false。
• 否则，将sum插入到set中，并将n更新为sum，继续下一次循环。

通过这样的循环，直到找到快乐数或进入无限循环为止。

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

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

时间复杂度分析：

• 在函数getSum中，对于给定的数n，需要计算n的每个位上数字的平方和。这个过程需要对n进行取余和除法操作，时间复杂度为O(log n)，其中n是输入的数。
• 在函数isHappy中，使用了一个无限循环while (true)来进行迭代计算。在每次循环中，需要调用getSum函数来计算平方和，时间复杂度为O(log n)。同时，还需要进行一次unordered_set的查找操作，时间复杂度为O(1)。因此，整个循环的时间复杂度可以近似看作O(log n)。

空间复杂度分析：

• 在函数isHappy中，使用了一个unordered_set来存储出现过的和sum，以便判断是否进入无限循环。在最坏情况下，如果输入的数一直不变，unordered_set可能会无限增长。
• 在循环过程中，unordered_set会保存所有不同的sum值，因此空间复杂度取决于循环的迭代次数，即O(log n)。
• 除此之外，还需要考虑函数调用栈的空间，由于没有递归调用，函数调用栈的空间复杂度为O(1)。

综上所述，该代码的时间复杂度为O(log n)，空间复杂度为O(log n)。