Orig Description
Score : 1300 points
Problem StatementYou are playing a game and your goal is to maximize your expected gain.
At the beginning of the game, a pawn is put, uniformly at random, at a position p\in\{1,2,\dots, N\}. The N positions are arranged on a circle (so that 1 is between N and 2).
The game consists of turns. At each turn you can either end the game, and get A_p dollars (where p is the current position of the pawn), or pay B_p dollar to keep playing.
If you decide to keep playing, the pawn is randomly moved to one of the two adjacent positions p-1, p+1 (with the identifications 0 = N and N+1=1).
What is the expected gain of an optimal strategy?
Note: The "expected gain of an optimal strategy" shall be defined as the supremum of the expected gain among all strategies such that the game ends in a finite number of turns.
Constraints
2 \le N \le 200,000
0 \le A_p \le 10^{12} for any p = 1,\ldots, N
0 \le B_p \le 100 for any p = 1, \ldots, N
All values in input are integers.
InputInput is given from Standard Input in the following format:
N
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N
OutputPrint a single real number, the expected gain of an optimal strategy.
Your answer will be considered correct if its relative or absolute error does not exceed 10^{-10}.
Sample Input 15
4 2 6 3 5
1 1 1 1 1
Sample Output 14.700000000000
Sample Input 24
100 0 100 0
0 100 0 100
Sample Output 250.000000000000
Sample Input 314
4839 5400 6231 5800 6001 5200 6350 7133 7986 8012 7537 7013 6477 5912
34 54 61 32 52 61 21 43 65 12 45 21 1 4
Sample Output 37047.142857142857
Sample Input 410
470606482521 533212137322 116718867454 746976621474 457112271419 815899162072 641324977314 88281100571 9231169966 455007126951
26 83 30 59 100 88 84 91 54 61
Sample Output 4815899161079.400024414062
Extracted Specification
An integer N (2 ≤ N ≤ 200,000), representing some quantity or size.
A list of integers A of size N, where each integer is between 0 and 10^12.
A list of integers B of size N, where each integer is between 0 and 100.
### Example Input:
```
5
4 2 6 3 5
1 1 1 1 1
```
### Function Signature:
Write a function f(N, A, B) that takes in the input.
def f(N: int, A: List[int], B: List[int]):
'''
N: an integer
A: a list of integers
B: a list of integers
'''
Test Case Generator
Sure, I can help you create a test case generator for this problem. The generator will create random values for \( N \), the arrays \( A \) and \( B \), and ensure that the constraints are respected. Here's how you can do it:
```python
import random
def generate_test_case():
# Generate random N within the given constraints
N = random.randint(2, 200000)
# Generate array A with values between 0 and 10^12
A = [random.randint(0, 10**12) for _ in range(N)]
# Generate array B with values between 0 and 100
B = [random.randint(0, 100) for _ in range(N)]
return N, A, B
# Example usage:
N, A, B = generate_test_case()
# Print the generated test case
print(N)
print(" ".join(map(str, A)))
print(" ".join(map(str, B)))
```
Let's break down what this generator does:
1. **Randomly Generate N**: It generates a random integer \( N \) between 2 and 200,000.
2. **Generate Array A**: It creates a list of \( N \) integers, each ranging from 0 to \( 10^{12} \).
3. **Generate Array B**: It creates a list of \( N \) integers, each ranging from 0 to 100.
This generator ensures that all constraints are respected and provides a random sample for testing the given problem. This is useful for testing the robustness and performance of your solution. You can run the generator multiple times to create various test cases.
Extract Arguments
def extract_arguments(fh):
N = int(fh.readline().strip())
A = list(map(int, fh.readline().strip().split()))
B = list(map(int, fh.readline().strip().split()))
return N, A, B