给定数字N。任务是找到硬币必须翻转才能连续获得N个正面的预期次数。
例子:
Input: N = 2
Output: 6
Input: N = 5
Output: 62
方法:
关键是要观察到,如果我们在连续N次翻转之间看到一条尾巴,则会破坏连续头部的条纹,而对于N次连续头部,我们必须重新开始。
令预期的试验次数为X,以获得N个连续的主管。以下是可能的情况:
- 情况1:如果在第一个试验中出现尾巴,则意味着我们已经浪费了一个试验,并且我们将不得不再进行X次试验才能获得N个连续的头部。该事件的概率为1/2 ,获得N个连续头部所需的试验总数为(X +先前试验浪费的计数) 。
- 情况2:如果在第二次试验中出现尾巴,则意味着我们已经浪费了所有先前的试验,并且我们将不得不再进行X次试验才能获得N个连续的头部。此事件的概率为1/4 ,获得N次连续翻转所需的总试验次数为(X +先前试验浪费的次数)。
- 情况3:如果在第3次试验中出现尾巴,则意味着我们已经浪费了之前的所有试验,并且我们将不得不再进行X次试验才能获得N。该事件的概率为1/8 ,获得N次连续翻转所需的总尝试次数为(X +先前浪费的尝试次数) 。这将一直持续到我们连续获得N个负责人为止。
- 案例N:类似地,如果在第N次试验中出现尾巴,则意味着我们已经浪费了之前所有的试验,并且我们将不得不再进行X次试验才能获得N。此事件的概率为1/2 N ,而获得N次连续翻转所需的总尝试次数为(X +先前浪费的尝试计数) 。
从上述情况来看,给出的所有概率之和将给出N个连续负责人的试验次数。数学上:
X = (1/2)*(X+1) + (1/4)*(X+2) + (1/8)*(X+3)+. . .+(1/2N)*(X+N) + (1/2N)*N
求解上面的X方程。我们具有:
By opening the above expressions and arranging it we have:
X = X(1/2 + 1/4 + 1/8 + . . . . . . 1/2N)
+ (1/2 + 2/4 + 3/8 . . . . . . . + N/2N
+ N/2N)
上述方程式的第一部分形成几何级数,而上述方程式的第二部分形成算术几何序列。分别解决上述序列,我们有:
对于几何序列:
Sum of GP series = 1/2 + 1/4 + 1/8 + . . . . . . 1/2N
first term(a) is 1/2
common ratio(r) is 1/2
last term (nth term) is 1/2N which is also a * rN-1
Hence sum is given by:
Sum of GP series = (1/2)*( (1 – (1/2)N)/(1 – 1/2) ) using formula : (a * (1 – rN)) / (1 – r) since r < 1
Sum of GP series = (1 – (1/2)N)
对于算术几何序列:
Let S = Sum of Arithmetico Geometric Sequence:
=> S = (1/2 + 2/4 + 3/8 + . . . . . . N/2N) …….(1)
Multiplying By 2, we get
=> 2S = (1 + 2/2 + 3/4 + . . . . . . . + N/2N-1) …….(2)
Subtracting the equation(1) from the equation(2), we get
=> S = (1/2 + 1/4 + 1/8 + . . . . . . 1/2N-1) – N/2N
=> S = sum of GP series – N/2N
=> S = (2 – (1/2)N-1)) – N/2N
使用GP系列和算术几何序列的总和:
=> X = X*(1 – (1/2)N) + (2 – (1/2)N-1) – N/2N + N/2N
=> X = X*(1 – (1/2)N) + (2 – (1/2)N-1)
=> X*((1/2)N) = (2 – (1/2)N-1)
=> X = 2N+1 – 2
现在X的上面的公式给出了需要连续N个试验头的试验次数。
下面是上述方法的实现:
C++
// C++ implementation of the above approach
#include "bits/stdc++.h"
using namespace std;
// Driver Code
int main()
{
int N = 3;
// Formula for number of trails for
// N consecutive heads
cout << pow(2, N + 1) - 2;
return 0;
}
Java
// Java implementation of the above approach
class GFG{
// Driver Code
public static void main(String[] args)
{
int N = 3;
// Formula for number of trails for
// N consecutive heads
System.out.print(Math.pow(2, N + 1) - 2);
}
}
// This code is contributed
// by shivanisinghss2110
Python3
# Python3 implementation of the above approach
# Driver code
if __name__ == '__main__':
N = 3
# Formula for number of trails for
# N consecutive heads
print(pow(2, N + 1) - 2)
# This code is contributed by mohit kumar 29
C#
// C# implementation of the above approach
using System;
class GFG{
// Driver Code
public static void Main()
{
int N = 3;
// Formula for number of trails for
// N consecutive heads
Console.Write(Math.Pow(2, N + 1) - 2);
}
}
// This code is contributed
// by Code_Mech
14
时间复杂度: O(1)