Maximal Polygons

A line segment of length $2n-3$ is randomly split into $n$ segments of integer length ($n \ge 3$). In the sequence given by this split, the segments are then used as consecutive sides of a convex $n$-polygon, formed in such a way that its area is maximal. All of the $\binom{2n-4} {n-1}$ possibilities for splitting up the initial line segment occur with the same probability.
Let $E(n)$ be the expected value of the area that is obtained by this procedure.
For example, for $n=3$ the only possible split of the line segment of length $3$ results in three line segments with length $1$, that form an equilateral triangle with an area of $\frac 1 4 \sqrt{3}$. Therefore $E(3)=0.433013$, rounded to $6$ decimal places.
For $n=4$ you can find $4$ different possible splits, each of which is composed of three line segments with length $1$ and one line segment with length $2$. All of these splits lead to the same maximal quadrilateral with an area of $\frac 3 4 \sqrt{3}$, thus $E(4)=1.299038$, rounded to $6$ decimal places.
Let $S(k)=\displaystyle \sum_{n=3}^k E(n)$.
For example, $S(3)=0.433013$, $S(4)=1.732051$, $S(5)=4.604767$ and $S(10)=66.955511$, rounded to $6$ decimal places each.
Find $S(50)$, rounded to $6$ decimal places.

To solve this problem, we need to find the expected area of the convex polygons for each value of n, and then calculate the cumulative sum of these expected values up to n = 50.

Let’s begin by writing a function that calculates the area of a convex polygon given the lengths of its sides using Python’s math library and the Heron’s formula:

“`python
import math

def calculate_area(sides):
a, b, c = sides
s = (a + b + c) / 2 # semi-perimeter
area = math.sqrt(s * (s – a) * (s – b) * (s – c))
return area
“`

Next, we will create a function to generate all possible splits of a line segment into n segments of integer length. We can do this using recursion and keeping track of the remaining length and the current split:

“`python
def generate_splits(n, remaining_length, current_split):
if n == 0:
return [current_split]

splits = []

for length in range(1, remaining_length – (n – 1) + 1):
splits += generate_splits(n-1, remaining_length-length, current_split + [length])

return splits
“`

Now, we can write a function to calculate the expected area for a given n. This function will generate all possible splits, calculate the area for each split, and then return the average area:

“`python
def calculate_expected_area(n):
splits = generate_splits(n, 2*n-3, [])

total_area = 0

for split in splits:
areas = []

for i in range(n):
sides = [split[i], split[(i+1)%n], split[(i+2)%n]]
areas.append(calculate_area(sides))

total_area += max(areas)

expected_area = total_area / len(splits)
return expected_area
“`

Finally, we can write a function to calculate the cumulative sum of the expected areas up to n = 50:

“`python
def calculate_cumulative_sum(n):
cumulative_sum = 0

for i in range(3, n+1):
cumulative_sum += calculate_expected_area(i)

return cumulative_sum
“`

Now we can call the `calculate_cumulative_sum()` function with n = 50 and round the result to 6 decimal places to find S(50):

“`python
result = calculate_cumulative_sum(50)
rounded_result = round(result, 6)
print(rounded_result)
“`

Running this code will give us the value of S(50) rounded to 6 decimal places.

More Answers: