89. 格雷编码
n 位格雷码序列 是一个由
2
n
2^n
2n 个整数组成的序列,其中:
每个整数都在范围
[
0
,
2
n
−
1
]
[0, 2^n - 1]
[0,2n−1] 内(含 0 和
2
n
−
1
2^n - 1
2n−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^x n==2x ,则认为 n 是 2 的幂次方。
示例 1:
输入:n = 1
输出:true
解释:
2
0
=
1
2^0 = 1
20=1
示例 2:
输入:n = 16
输出:true
解释:
2
4
=
16
2^4 = 16
24=16
示例 3:
输入:n = 3
输出:false
示例 4:
输入:n = 4
输出:true
示例 5:
输入:n = 5
输出:false
提示:
− 2 31 < = n < = 2 31 − 1 -2^{31} <= n <= 2^{31} - 1 −231<=n<=231−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;
}
};
代码的运行结果如下:
但是这道题目,题解1的代码更加精彩。
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;
}
};
官方题解2还给出了一种做法,就是分别搜索p,q,并记录它们的路径,最后寻找他们公共路径的最后一个节点,就是他们的公共祖先。
292. Nim 游戏
你和你的朋友,两个人一起玩 Nim 游戏:
桌子上有一堆石头。
你们轮流进行自己的回合, 你作为先手 。
每一回合,轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数,来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢,返回 true;否则,返回 false 。
示例 1:
输入:n = 4
输出:false
解释:以下是可能的结果:
- 移除1颗石头。你的朋友移走了3块石头,包括最后一块。你的朋友赢了。
- 移除2个石子。你的朋友移走2块石头,包括最后一块。你的朋友赢了。
- 你移走3颗石子。你的朋友移走了最后一块石头。你的朋友赢了。
在所有结果中,你的朋友是赢家。
示例 2:
输入:n = 1
输出:true
示例 3:
输入:n = 2
输出:true
提示:
1 < = n < = 2 31 − 1 1 <= n <= 2^{31} - 1 1<=n<=231−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;
}
}
};