leetcode刷题记录32（2024-1-19）【格雷编码(数学) | 2 的幂(数论、数学) | 二叉搜索树的最近公共祖先(二叉搜索树) | Nim 游戏(博弈论)】

89. 格雷编码

n 位格雷码序列 是一个由 $2^n$ 个整数组成的序列，其中：
每个整数都在范围 $[0,2^n-1]$ 内（含 0 和 $2^n-1$）
第一个整数是 0
一个整数在序列中出现 不超过一次
每对 相邻 整数的二进制表示 恰好一位不同 ，且
第一个 和 最后一个 整数的二进制表示 恰好一位不同
给你一个整数 n ，返回任一有效的 n 位格雷码序列 。

示例 1：

输入：n = 2
输出：[0,1,3,2]
解释：
[0,1,3,2] 的二进制表示是 [00,01,11,10] 。

• 00 和 01 有一位不同
• 01 和 11 有一位不同
• 11 和 10 有一位不同
• 10 和 00 有一位不同
  [0,2,3,1] 也是一个有效的格雷码序列，其二进制表示是 [00,10,11,01] 。
• 00 和 10 有一位不同
• 10 和 11 有一位不同
• 11 和 01 有一位不同
• 01 和 00 有一位不同

示例 2：

输入：n = 1
输出：[0,1]

提示：

1 <= n <= 16

这道题并没有AC出来，参考了题解之后，发现是一道数学原理比较强的题目，因为基本都是参考的题解，就不再过多解读了。

方法1：归纳法

class Solution
{
public:
    vector<int> grayCode(int n)
    {
        vector<int> res;
        res.reserve(1 << n);
        res.push_back(0);
        for (int i = 1; i <= n; i++)
        {
            int m = res.size();
            for (int j = m - 1; j >= 0; j--)
            {
                res.push_back(res[j] | (1 << (i - 1)));
            }
        }
        return res;
    }
};

方法2：公式法

class Solution
{
public:
    vector<int> grayCode(int n)
    {
        vector<int> res(1 << n);
        for (int i = 0; i < res.size(); i++)
        {
            res[i] = i ^ (i >> 1);
        }
        return res;
    }
};

231. 2 的幂

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 $n==2^x$ ，则认为 n 是 2 的幂次方。

示例 1：

输入：n = 1
输出：true
解释：$2^0=1$

示例 2：

输入：n = 16
输出：true
解释：$2^4=16$

示例 3：

输入：n = 3
输出：false

示例 4：

输入：n = 4
输出：true

示例 5：

输入：n = 5
输出：false

提示：

$-2^{31}<=n<=2^{31}-1$

进阶：你能够不使用循环/递归解决此问题吗？

最简单的做法，就是取余和除以2，来进行循环，当然这种做法的时间复杂度是O(logn)的级别。

class Solution
{
public:
    bool isPowerOfTwo(int n)
    {
        if (n <= 0)
            return false;
        while (n % 2 == 0)
        {
            n = n >> 1;
        }
        return n == 1 ? true : false;
    }
};

不用循环的做法，就是通过逻辑运算，来实现O(1)的做法。自己的思路是，2的n次方的二进制表示中，只有一个数是1，其它全部是0，因此，我们只要把这个最低位取出来，然后和原数进行比较就可以了。

如果n的二进制表示是100，那么n-1就为011，这样我再按位取反得到100，然后二者进行&运算，就可以得到100，和原数100相等，因此是2的n次方。

如果n的二进制表示是1100，那么n-1是1011，按位取反为0100，与n进行&操作后，为0100，不等于1100，所以不是2的n次方。

代码如下：

class Solution
{
public:
    bool isPowerOfTwo(int n)
    {
        if (n <= 0)
            return false;
        int lowBit = n & (~(n - 1));
        return lowBit == n ? true : false;
    }
};

代码的运行结果如下：

但是这道题目，题解¹的代码更加精彩。

235. 二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉搜索树中。

这道题目要注意运用到二叉搜索树这个条件，也就是这个二叉树是有序的，这一点很关键，如果这个二叉树是无序的，那么就按照https://blog.csdn.net/myf_666/article/details/131484071中的第三道题目二叉树的公共祖先通过递归的方法，分解问题来处理。

那么这道题无疑是更简单了，只需要找到一个节点，使得这个节点的val位于两个节点（p，q）的中间，或者这个节点的val就是两个节点（p，q）中的一个值。

// Definition for a binary tree node.
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution
{
public:
    TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q)
    {
        TreeNode *bothFather = root;
        while (true)
        {
            if (bothFather == nullptr)
            {
                return nullptr;
            }
            else if (bothFather->val > p->val && bothFather->val > q->val)
            {
                bothFather = bothFather->left;
            }
            else if (bothFather->val < p->val && bothFather->val < q->val)
            {
                bothFather = bothFather->right;
            }
            else{
                break;
            }
        }
        return bothFather;
    }
};

官方题解²还给出了一种做法，就是分别搜索p，q，并记录它们的路径，最后寻找他们公共路径的最后一个节点，就是他们的公共祖先。

292. Nim 游戏

你和你的朋友，两个人一起玩 Nim 游戏：

桌子上有一堆石头。
你们轮流进行自己的回合， 你作为先手 。
每一回合，轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。

示例 1：

输入：n = 4
输出：false
解释：以下是可能的结果:

1. 移除1颗石头。你的朋友移走了3块石头，包括最后一块。你的朋友赢了。
2. 移除2个石子。你的朋友移走2块石头，包括最后一块。你的朋友赢了。
3. 你移走3颗石子。你的朋友移走了最后一块石头。你的朋友赢了。
   在所有结果中，你的朋友是赢家。

示例 2：

输入：n = 1
输出：true
示例 3：

输入：n = 2
输出：true

提示：

$1<=n<=2^{31}-1$

这道题目自己的做法和题解的做法一致。

具体思路是，对于3块及3块以下的石头，先手可以一次性全部拿走，这样先手就赢了。

石头块数	1	2	3
先手是否能赢	T	T	T

对于4块石头呢？先手只能拿1块、2块、3块，分别将其转化成3块、2块、1块，然后给后手，这样后手就可以赢了，所以对于4块石头，先手无法赢。

石头块数	1	2	3	4
先手是否能赢	T	T	T	F

那么对于石头块数为5、6、7的情况呢？先手可以通过拿走1块、2块、3块的方式，把这三种情况转化为4块石头，然后踢给后手，这样后手相当于4块情况下的先手，他就输了，进而先手获胜。

石头块数	1	2	3	4	5	6	7
先手是否能赢	T	T	T	F	T	T	T

那么对于8块石头的情况呢？先手无论拿1块、2块还是3块，都会分别将其转化成7块、6块、5块的情况，然后转给后手，这样后手就成为了7块、6块、5块情况下的先手，就会赢了，进而先手输。

石头块数	1	2	3	4	5	6	7	8
先手是否能赢	T	T	T	F	T	T	T	F

通过上边的分析推理，很容易发现，每3个T，就对应着一个F，如此进行循环，我们可以通过取余运算来实现这个循环，代码如下：

class Solution
{
public:
    bool canWinNim(int n)
    {
        if (n % 4 == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
};

---

1. https://leetcode.cn/problems/power-of-two/solutions/796201/2de-mi-by-leetcode-solution-rny3/ ↩︎

2. https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/solutions/428633/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-26/ ↩︎