一行代码就能够经过 LeetCode？来看下我是怎么作到的！

这是一道 LeetCode 为数很少的几率题，咱们来看下。原题地址：https://leetcode-cn.com/probl...

题目描述

有 n 位乘客即将登机，飞机正好有 n 个座位。第一位乘客的票丢了，他随便选了一个座位坐下。

剩下的乘客将会：

若是他们本身的座位还空着，就坐到本身的座位上，

当他们本身的座位被占用时，随机选择其余座位
第 n 位乘客坐在本身的座位上的几率是多少？

 

示例 1：

输入：n = 1
输出：1.00000
解释：第一我的只会坐在本身的位置上。
示例 2：

输入: n = 2
输出: 0.50000
解释：在第一我的选好座位坐下后，第二我的坐在本身的座位上的几率是 0.5。
 

提示：

1 <= n <= 10^5

暴力递归

这是一道 LeetCode 为数很少的几率题，咱们来看下。

思路

咱们定义原问题为 f(n)。对于第一我的来讲，他有 n 中选择，就是分别选择 n 个座位中的一个。因为选择每一个位置的几率是相同的，那么选择每一个位置的几率应该都是 1 / n。

咱们分三种状况来讨论：

• 若是第一我的选择了第一我的的位置（也就是选择了本身的位置），那么剩下的人按照票上的座位作就行了，这种状况第 n 我的必定能作到本身的位置
• 若是第一我的选择了第 n 我的的位置，那么第 n 我的确定坐不到本身的位置。
• 若是第一我的选择了第 i (1 < i < n)我的的位置，那么第 i 我的就至关于变成了“票丢的人”，此时问题转化为 f(n - i + 1)。

此时的问题转化关系如图：

（红色表示票丢的人）

整个过程分析：

代码

代码支持 Python3:

Python3 Code:

class Solution:
    def nthPersonGetsNthSeat(self, n: int) -> float:
        if n == 1:
            return 1
        if n == 2:
            return 0.5
        res = 1 / n
        for i in range(2, n):
            res += self.nthPersonGetsNthSeat(n - i + 1) * 1 / n
        return res

上述代码会栈溢出。

暴力递归 + hashtable

思路

咱们考虑使用记忆化递归来减小重复计算，虽然这种作法能够减小运行时间，可是对减小递归深度没有帮助。仍是会栈溢出。

代码

代码支持 Python3:

Python3 Code:

class Solution:
    seen = {}

    def nthPersonGetsNthSeat(self, n: int) -> float:
        if n == 1:
            return 1
        if n == 2:
            return 0.5
        if n in self.seen:
            return self.seen[n]
        res = 1 / n
        for i in range(2, n):
            res += self.nthPersonGetsNthSeat(n - i + 1) * 1 / n
        self.seen[n] = res
        return res

动态规划

思路

上面作法会栈溢出。其实咱们根本不须要运行就应该能判断出栈溢出，题目已经给了数据规模是 1 <= n <= 10 ** 5。 这个量级无论什么语言，除非使用尾递归，否则通常都会栈溢出，具体栈深度你们能够查阅相关资料。

既然是栈溢出，那么咱们考虑使用迭代来完成。 很容易想到使用动态规划来完成。其实递归都写出来，写一个朴素版的动态规划也难不到哪去，毕竟动态规划就是记录子问题，并创建子问题之间映射而已，这和递归并没有本质区别。

代码

代码支持 Python3:

Python3 Code:

class Solution:
    def nthPersonGetsNthSeat(self, n: int) -> float:
        if n == 1:
            return 1
        if n == 2:
            return 0.5

        dp = [1, .5] * n

        for i in range(2, n):
            dp[i] = 1 / n
            for j in range(2, i):
                dp[i] += dp[i - j + 1] * 1 / n
        return dp[-1]

这种思路的代码超时了，而且仅仅执行了 35/100 testcase 就超时了。

数学分析

思路

咱们还须要进一步优化时间复杂度，咱们须要思考是否能够在线性的时间内完成。

咱们继续前面的思路进行分析, 不可贵出，咱们不妨称其为等式 1：

f(n)
= 1/n + 0 + 1/n * (f(n-1) + f(n-2) + ... + f(2))
= 1/n * (f(n-1) + f(n-2) + ... + f(2) + 1)
= 1/n * (f(n-1) + f(n-2) + ... + f(2) + f(1))

彷佛更复杂了？不要紧，咱们继续往下看，咱们看下 f(n - 1)，咱们不妨称其为等式 2。

f(n-1) = 1/(n-1) * (f(n-2) + f(n-3) + ... + f(1))

咱们将等式 1 和等式 2 两边分别同时乘以 n 和 n - 1

n * f(n) = f(n-1) + f(n-2) + f(n-3) + ... + f(1)
(n-1) * f(n-1) = f(n-2) + f(n-3) + ... + f(1)

咱们将二者相减：

n * f(n) - (n-1)*f(n-1) = f(n-1)

咱们继续将 (n-1)*f(n-1) 移到等式右边，获得：

n * f(n) = n * f(n-1)

也就是说:

f(n) = f(n - 1)

固然前提是 n 大于 2。

既然如此，咱们就能够减小一层循环， 咱们用这个思路来优化一下上面的 dp 解法。这种解法终于能够 AC 了。

代码

代码支持 Python3:

Python3 Code:

class Solution:
    def nthPersonGetsNthSeat(self, n: int) -> float:
        if n == 1:
            return 1
        if n == 2:
            return 0.5

        dp = [1, .5] * n

        for i in range(2, n):
            dp[i] = 1/n+(n-2)/n * dp[n-1]
        return dp[-1]

优化数学分析

思路

上面咱们经过数学分析，得出了当 n 大于 2 时：

f(n) = f(n - 1)

那么是否是意味着咱们随便求出一个 n 就行了？ 好比咱们求出 n = 2 的时候的值，是否是就知道 n 为任意数的值了。 咱们不难想出 n = 2 时候，几率是 0.5，所以只要 n 大于 1 就是 0.5 几率，不然就是 1 几率。

代码

代码支持 Python3:

Python3 Code:

class Solution:
    def nthPersonGetsNthSeat(self, n: int) -> float:
        return 1 if n == 1 else .5

关键点

• 几率分析
• 数学推导
• 动态规划
• 递归 + mapper
• 栈限制大小
• 尾递归