算法数据结构中有哪些奇技淫巧？

***************************第一道*******************************

题目描述

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1] 输出: 1

示例 2:

输入: [4,1,2,1,2] 输出: 4

题目解析

根据题目描述，由于加上了时间复杂度必须是O(n)，并且空间复杂度为O(1)的条件，因此不能用排序方法，也不能使用map数据结构。

小吴想了一下午没想出来，答案是使用 位操作Bit Operation 来解此题。

将所有元素做异或运算，即a[1] ⊕ a[2] ⊕ a[3] ⊕ …⊕ a[n]，所得的结果就是那个只出现一次的数字，时间复杂度为O(n)。

异或

异或运算A ⊕ B的真值表如下：

AB⊕FFFFTTTFTTTF

动画演示

进阶版

有一个 n 个元素的数组，除了两个数只出现一次外，其余元素都出现两次，让你找出这两个只出现一次的数分别是几，要求时间复杂度为 O(n) 且再开辟的内存空间固定(与 n 无关)。

示例 :

输入: [1,2,2,1,3,4] 输出: [3,4]

题目再解析

根据前面找一个不同数的思路算法，在这里把所有元素都异或，那么得到的结果就是那两个只出现一次的元素异或的结果。

然后，因为这两个只出现一次的元素一定是不相同的，所以这两个元素的二进制形式肯定至少有某一位是不同的，即一个为 0 ，另一个为 1 ，现在需要找到这一位。

根据异或的性质 任何一个数字异或它自己都等于 0，得到这个数字二进制形式中任意一个为 1 的位都是我们要找的那一位。

再然后，以这一位是 1 还是 0 为标准，将数组的 n 个元素分成两部分。

• 将这一位为 0 的所有元素做异或，得出的数就是只出现一次的数中的一个
• 将这一位为 1 的所有元素做异或，得出的数就是只出现一次的数中的另一个。

这样就解出题目。忽略寻找不同位的过程，总共遍历数组两次，时间复杂度为O(n)。

动画再演示

***************************第二道*******************************

题目来源于 LeetCode 上第 231 号问题：2 的幂。题目难度为 Easy，目前通过率为 45.6% 。

题目描述

给定一个整数，编写一个函数来判断它是否是 2 的幂次方。

示例 1:

输入: 1
输出: true
解释: 20 = 1

示例 2:

输入: 16
输出: true
解释: 24 = 16

示例 3:

输入: 218
输出: false

题目解析

首先，先来分析一下 2 的次方数的二进制写法：

仔细观察，可以看出 2 的次方数都只有一个 1 ，剩下的都是 0 。根据这个特点，只需要每次判断最低位是否为 1 ，然后向右移位，最后统计 1 的个数即可判断是否是 2 的次方数。

代码很简单：

class Solution {
public:
    bool isPowerOfTwo(int n) {
        int cnt = 0;
        while (n > 0) {
            cnt += (n & 1);
            n >>= 1;
        }
        return cnt == 1;
    } 
};

该题还有一种巧妙的解法。再观察上面的表格，如果一个数是 2 的次方数的话，那么它的二进数必然是最高位为1，其它都为 0 ，那么如果此时我们减 1 的话，则最高位会降一位，其余为 0 的位现在都为变为 1，那么我们把两数相与，就会得到 0。

比如 2 的 3 次方为 8，二进制位 1000 ，那么 8 - 1 = 7，其中 7 的二进制位 0111。

图片描述

代码实现

利用这个性质，只需一行代码就可以搞定。

class Solution {
public:
    bool isPowerOfTwo(int n) {
        return (n > 0) && (!(n & (n - 1)));
    } 
};

秀不秀，值得双击点个赞~

***************************第三道*******************************

### 题目描述

给定一个整数 (32 位有符号整数)，请编写一个函数来判断它是否是 4 的幂次方。

示例 1:

输入: 16
输出: true

示例 2:

输入: 5
输出: false

进阶： 你能不使用循环或者递归来完成本题吗？

题目解析

这道题最直接的方法就是不停的去除以 4 ，看最终结果是否为 1 ，参见代码如下：

class Solution {
    public boolean isPowerOfFour(int num) {
         while ( (num != 0)  && (num % 4 == 0)) {
            num /= 4;
        }
        return num == 1;
    }
}

不过这段代码使用了 循环 ，逼格不够高。

对于一个整数而言，如果这个数是 4 的幂次方，那它必定也是 2 的幂次方。

我们先将 2 的幂次方列出来找一下其中哪些数是 4 的幂次方。

十进制二进制2104100 (1 在第 3 位)810001610000(1 在第 5 位)32100000641000000(1 在第 7 位)12810000000256100000000(1 在第 9 位)5121000000000102410000000000(1 在第 11 位)

找一下规律： 4 的幂次方的数的二进制表示 1 的位置都是在奇数位。

之前在小吴的文章中判断一个是是否是 2 的幂次方数使用的是位运算 n & ( n - 1 )。同样的，这里依旧可以使用位运算：将这个数与特殊的数做位运算。

这个特殊的数有如下特点：

• 足够大，但不能超过 32 位，即最大为 1111111111111111111111111111111( 31 个 1)
• 它的二进制表示中奇数位为 1 ，偶数位为 0 符合这两个条件的二进制数是：

1010101010101010101010101010101

如果用一个 4 的幂次方数和它做与运算，得到的还是 4 的幂次方数。

将这个二进制数转换成 16 进制表示：0x55555555 。有没有感觉逼格更高点。。。

代码实现

class Solution {
    public boolean isPowerOfFour(int num) {
        if (num <= 0)
            return false;
        //先判断是否是 2 的幂
        if ((num & num - 1) != 0)
            return false;
        //如果与运算之后是本身则是 4 的幂
        if ((num & 0x55555555) == num)
            return true;
        return false;
    }
}

***************************第四道*******************************

题目描述

喜羊羊和灰太狼用几堆石子在做游戏。偶数堆石子排成一行，每堆都有正整数颗石子 piles[i] 。

游戏以谁手中的石子最多来决出胜负。石子的总数是奇数，所以没有平局。

喜羊羊和灰太狼轮流进行，喜羊羊先开始。 每回合，玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止，此时手中石子最多的玩家获胜。

假设喜羊羊和灰太狼都发挥出最佳水平，当喜羊羊赢得比赛时返回 true ，当灰太狼赢得比赛时返回 false 。

题目分析

举两个例子来帮助理解题意。

例子一：

输入：[ 5，3，4，5 ]

输出：true

解释：

喜羊羊先开始，只能拿前 5 颗或后 5 颗石子 。

假设他取了前 5 颗，这一行就变成了 [ 3 ，4，5 ] 。

如果灰太狼拿走前 3 颗，那么剩下的是 [ 4，5 ]，喜羊羊拿走后 5 颗赢得 10 分。

如果灰太狼拿走后 5 颗，那么剩下的是 [ 3，4 ]，喜羊羊拿走后 4 颗赢得 9 分。

这表明，取前 5 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。

例子二：

输入：[ 5，10000，2，3 ]

输出：true

解释：

喜羊羊先开始，只能拿前 5 颗或后 3 颗石子 。

假设他取了后 3 颗，这一行就变成了 [ 5，10000，2 ]。

灰太狼肯定会在剩下的这一行中取走前 5 颗，这一行就变成了 [ 10000，2 ]。

然后喜羊羊取走前 10000 颗，总共赢得 10003 分，灰太狼赢得 7 分。

这表明，取后 3 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。

这个例子表明，并不是需要每次都挑选最大的那堆石头。

题目回答

涉及到最优解的问题，那么肯定要去尝试一下使用 **动态规划 **来解决了。

先看一下力扣的正规题解：

让我们改变游戏规则，使得每当灰太狼得分时，都会从喜羊羊的分数中扣除。

令 dp(i, j) 为喜羊羊可以获得的最大分数，其中剩下的堆中的石子数是 piles[i], piles[i+1], ..., piles[j]。这在比分游戏中很自然：我们想知道游戏中每个位置的值。

我们可以根据 dp(i + 1，j) 和 dp(i，j-1) 来制定 dp(i，j) 的递归，我们可以使用动态编程以不重复这个递归中的工作。(该方法可以输出正确的答案，因为状态形成一个DAG(有向无环图)。)

当剩下的堆的石子数是 piles[i], piles[i+1], ..., piles[j] 时，轮到的玩家最多有 2 种行为。

可以通过比较 j-i和 N modulo 2 来找出轮到的人。

如果玩家是喜羊羊，那么它将取走 piles[i] 或 piles[j] 颗石子，增加它的分数。之后，总分为 piles[i] + dp(i+1, j) 或 piles[j] + dp(i, j-1)；我们想要其中的最大可能得分。

如果玩家是灰太狼，那么它将取走 piles[i] 或 piles[j] 颗石子，减少喜羊羊这一数量的分数。之后，总分为 -piles[i] + dp(i+1, j) 或 -piles[j] + dp(i, j-1)；我们想要其中的最小可能得分。

代码如下：

上面的代码并不算复杂，当然，如果你看不懂也没关系，不影响解决问题，请看下面的数学分析。

数学分析

因为石头的数量是奇数，因此只有两种结果，输或者赢。

喜羊羊先开始拿石头，随便拿！然后比较石头数量：

1. 如果石头数量多于对手，赢了；
2. 如果石头数量少于对手，自己拿石头的顺序和对手拿石头的顺序对调，还是赢。

所以代码如下：

class Solution {
    public boolean stoneGame(int[] piles) {
        return true;
    }
}

看完之后，你的心情是怎么样的？

***************************第五道*******************************

题目来源于 LeetCode 上第 172 号问题：阶乘后的零。题目难度为 Easy，目前通过率为 38.0% 。

题目描述

给定一个整数 n，返回 n! 结果尾数中零的数量。

示例 1:

输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。

示例 2:

输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.

说明: 你算法的时间复杂度应为 O(log n) 。

题目解析

题目很好理解，数阶乘后的数字末尾有多少个零。

最简单粗暴的方法就是先乘完再说，然后一个一个数。

事实上，你在使用暴力破解法的过程中就能发现规律： 这 9 个数字中只有 2(它的倍数) 与 5 (它的倍数)相乘才有 0 出现。

所以，现在问题就变成了这个阶乘数中能配 多少对 2 与 5。

举个复杂点的例子：

10！ = 【 2 *( 2 * 2 )* 5 *( 2 * 3 )*( 2 * 2 * 2 )*( 2 * 5)】

在 10！这个阶乘数中可以匹配两对 2 * 5 ，所以10！末尾有 2 个 0。

可以发现，一个数字进行拆分后 2 的个数肯定是大于 5 的个数的，所以能匹配多少对取决于 5 的个数。(好比现在男女比例悬殊，最多能有多少对异性情侣取决于女生的多少)。

那么问题又变成了 统计阶乘数里有多少个 5 这个因子。

需要注意的是，像 25，125 这样的不只含有一个 5 的数字的情况需要考虑进去。

比如 n = 15。那么在 15! 中 有 3 个 5 (来自其中的5, 10, 15)， 所以计算 n/5 就可以 。

但是比如 n=25，依旧计算 n/5 ，可以得到 5 个5，分别来自其中的5, 10, 15, 20, 25，但是在 25 中其实是包含 2个 5 的，这一点需要注意。

所以除了计算 n/5 ， 还要计算 n/5/5 , n/5/5/5 , n/5/5/5/5 , ..., n/5/5/5,,,/5直到商为0，然后求和即可。

代码实现

public class Solution {
    public int trailingZeroes(int n) {
        return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
    }
}

我的专栏：

和程序员小吴一起学算法

❤️ 看完三件事：

如果你觉得这篇内容对你挺有启发，我想邀请你帮我三个忙：

1. 点赞，让更多的人也能看到这篇内容(收藏不点赞，都是耍流氓 -_-)
2. 关注我和专栏，让我们成为长期关系
3. 关注公众号「五分钟学算法」，第一时间阅读最新的算法文章，公众号后台回复 1024 送你 50 本 算法编程书籍。