Problem:


Score : 1000 points

Problem Statement

   #nck {
      width: 30px;
      height: auto;
   }

There are N balls and N+1 holes in a line. Balls are numbered 1 through N from left to right. Holes are numbered 1 through N+1 from left to right. The i-th ball is located between the i-th hole and (i+1)-th hole. We denote the distance between neighboring items (one ball and one hole) from left to right as d_i (1 \leq i \leq 2 \times N). You are given two parameters d_1 and x. d_i - d_{i-1} is equal to x for all i (2 \leq i \leq 2 \times N).

We want to push all N balls into holes one by one. When a ball rolls over a hole, the ball will drop into the hole if there is no ball in the hole yet. Otherwise, the ball will pass this hole and continue to roll. (In any scenario considered in this problem, balls will never collide.)

In each step, we will choose one of the remaining balls uniformly at random and then choose a direction (either left or right) uniformly at random and push the ball in this direction. Please calculate the expected total distance rolled by all balls during this process.

For example, when N = 3, d_1 = 1, and x = 1, the following is one possible scenario:

first step: push the ball numbered 2 to its left, it will drop into the hole numbered 2. The distance rolled is 3.

second step: push the ball numbered 1 to its right, it will pass the hole numbered 2 and drop into the hole numbered 3. The distance rolled is 9.

third step: push the ball numbered 3 to its right, it will drop into the hole numbered 4. The distance rolled is 6.

So the total distance in this scenario is 18.

Note that in all scenarios every ball will drop into some hole and there will be a hole containing no ball in the end.

Constraints

1 \leq N \leq 200,000

1 \leq d_1 \leq 100

0 \leq x \leq 100

All input values are integers.

Input

The input is given from Standard Input in the following format:

N d_1 x

Output

Print a floating number denoting the answer. The relative or absolute error of your answer should not be higher than 10^{-9}.

Sample Input 1

1 3 3

Sample Output 1

4.500000000000000

The distance between the only ball and the left hole is 3 and distance between the only ball and the right hole is 6. There are only two scenarios (i.e. push left and push right). The only ball will roll 3 and 6 unit distance, respectively. So the answer for this example is (3+6)/2 = 4.5.

Sample Input 2

2 1 0

Sample Output 2

2.500000000000000

Sample Input 3

1000 100 100

Sample Output 3

649620280.957660079002380



Sample input:
1 3 3


Sample output:
4.500000000000000

Submission status: Wrong Answer

Solution code:
N = 1000
d1 = 100
xx = 100

d = d1*1.0
x = xx*1.0

res = 0.0

while N > 1:
    res += (2*d + (2*N-1)*x) / 2
    d *= 1.0 + 1.0 / N
    d += x * 5.0/(2*N)
    x *= 1.0 + 2.0 / N
    N -= 1

print "{:.12f}".format(res + d + x/2)

Submission status: Wrong Answer

Solution code:
memo = {0: 0}

def left(s, i):
    hall_i = i
    while s & 1 << hall_i:
        hall_i -= 1

    return balls[i] - halls[hall_i]

def right(s, i):
    hall_i = i + 1
    while s & 1 << hall_i:
        hall_i += 1

    return halls[hall_i] - balls[i]


def solve(s):
#    print(('solve {0:0' + str(N) + 'b}').format(s))

    if s not in memo:
        ans = 0
        cnt = 0
        for i in range(N + 1):
            if s & 1 << i:
                sp = s ^ 1 << i
                ans += solve(sp) + (left(sp, i) + right(sp, i)) / 2
                cnt += 1
        memo[s] = ans / cnt

#    print(('solve {0:0' + str(N) + 'b}').format(s), '=', memo[s])

    return memo[s]

N, d1, x = [int(x) for x in input().split()]
intervals = [d1 + i * x for i in range(N * 2)]
balls = [d1]
for i in range(1, N):
    balls.append(balls[-1] + intervals[2 * i - 1] + intervals[2 * i])
halls = [0]
for i in range(N):
    halls.append(halls[-1] + intervals[2 * i] + intervals[2 * i + 1])

for i in range((1 << N) - 1):
    solve(i)

print(solve((1 << N) - 1))

Submission status: Time Limit Exceeded

Solution code:
from decimal import Decimal
N=0;A=Decimal('.0');X=Decimal('.0');M=0;
A2=Decimal('.0');X2=Decimal('.0');M2=Decimal('.0');
S=Decimal('.0');E=Decimal('.0');Ans=Decimal('.0');
cin = input().split()
N=int(cin[0])
A=Decimal(cin[1])
X=Decimal(cin[2])
M=2*N
for i in range(1, N):
    A2 = ((M+2)*A + 5*X) / M; 
    X2 = (M+4) * X / M;
    M2 = M-2;
    S = A*M + M*(M-1)*X/2;
    E = A2*M2 + M2*(M2-1)*X2/2;
    Ans+=S/M; 
    A=A2; X=X2; M=M2;
Ans+=(A*2+X)/2; 
print(Ans)

Submission status: Time Limit Exceeded

Solution code:
from decimal import Decimal

n, d, x = map(Decimal, input().split())
print((d + (2 * n - 1) * x / 2) * sum((n - i) / (i + 1) for i in range(int(n))))

Submission status: Time Limit Exceeded

Solution code:
from decimal import Decimal


def solve(n, d, x):
    ans = 0
    while n:
        ans += d + (2 * n - 1) * x / 2
        d = ((n + 1) * d + 5 * x / 2) / n
        x *= (n + 2) / n
        n -= 1
    return ans


print(solve(*map(Decimal, input().split())))

Submission status: Time Limit Exceeded

Solution code:
import sys

from decimal import Decimal

sys.setrecursionlimit(200000)


def solve(n, d, x):
    ans = 0
    while n:
        ans += d + (2 * n - 1) * x / 2
        d = ((n + 1) * d + 5 * x / 2) / n
        x *= (n + 2) / n
        n -= 1
    return ans


print(solve(*map(Decimal, input().split())))

Submission status: Time Limit Exceeded

Solution code:
import sys

from decimal import Decimal

sys.setrecursionlimit(200000)


def solve(n, d, x):
    if not n:
        return 0
    return d + (2 * n - 1) * x / 2 + solve(n - 1, ((n + 1) * d + 5 * x / 2) / n, (n + 2) * x / n)


print(solve(*map(Decimal, input().split())))

Submission status: Accepted

Solution code:
from decimal import Decimal, getcontext
getcontext().prec = 200
n, d, x = map(Decimal, input().split())
ans = 0
for i in range(1, int(n) + 1):
    i = Decimal(str(i))
    ans += Decimal(str((int(n) - int(i) + 1))) / Decimal(str(i)) * (d + x * Decimal(str(int(n) * 2 - 1)) / Decimal("2"))
print(ans)

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N, d, x = map(int, read().split())

def main(N, d, x):
    ret = 0
    while N:
        ret += d + (N-0.5) * x
        d = d + (d/N) + (5*x)/(2*N)
        x += 2*x/N
        N -= 1
    return ret

print(main(N, d, x))

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N,D,X = map(int,read().split())

answer = 0
for n in range(N,0,-1):
    mean = D + X * (n+n-1) / 2
    answer += mean
    D = ((n+n+2) * D + 5 * X) / (2*n)
    X = (n + 2) * X / n

print(answer)

Submission status: Accepted

Solution code:
N,D,X = map(int,input().split())

"""
・玉の位置は無視できる
・等差数列なので左右反転して平均化→完全等間隔に帰着
・ひとつ取り去ったあとの平均化→それも完全等間隔の定数倍
・すべての間隔が1であるN区間の場合の期待値を求める
"""

x = .5
for n in range(2,N+1):
    x += .5 + x/n

answer = x * (2*D+X*(2*N-1))
print(answer)

Submission status: Accepted

Solution code:
def solve(n, d, x):
    ans = 0
    while n:
        ans += d + (2 * n - 1) * x / 2
        d = ((n + 1) * d + 5 * x / 2) / n
        x *= (n + 2) / n
        n -= 1
    return ans


print('{:.10f}'.format(solve(*map(float, input().split()))))

Submission status: Accepted

Solution code:
N, d1, xx = map(int, raw_input().split())

d = d1*1.0
x = xx*1.0

res = 0.0

while N > 1:
    res += (2*d + (2*N-1)*x) / 2
    d *= 1.0 + 1.0 / N
    d += x * 5.0/(2*N)
    x *= 1.0 + 2.0 / N
    N -= 1

print "{:.12f}".format(res + d + x/2)

Submission status: Accepted

Solution code:
n, d, x = map(int, raw_input().split())
ans = (d + d + x + d + 2 *(n - 1) * x + d + (2 * (n - 1) + 1) * x) / 4.0
s = 0.5 * n
for i in xrange(1, n):
    s += 0.5 / (i + 1) * (n - i)
print "%.12f" %  (ans * s * 2)

Submission status: Runtime Error

Solution code:
import sys

sys.setrecursionlimit(200000)


def solve(n, d, x):
    if not n:
        return 0
    return d + (2 * n - 1) * x / 2 + solve(n - 1, ((n + 1) * d + 5 * x / 2) / n, (n + 2) * x / n)


print(solve(*map(int, input().split())))