Program to find expected sum of subarrays of a given array by performing some operations in Python

Given an array A of size n and two values p and q, we need to find the expected sum of subarrays after performing specific operations. This problem involves probability calculations and matrix operations to determine the expected value.

Problem Understanding

We can perform two types of operations on array A:

• Randomly select two indices (l, r) where l < r, then swap A[l] and A[r]
• Randomly select two indices (l, r) where l < r, then reverse subarray A[l..r]

After performing the first operation p times and second operation q times, we randomly select indices l and r where l < r, calculate S = sum of elements A[l..r], and find the expected value of S.

Example Walkthrough

For A = [1,2,3], p = 1, q = 1:

Step 1: Three possible swaps −

• swap(0, 1) ? [2, 1, 3]
• swap(0, 2) ? [3, 2, 1]
• swap(1, 2) ? [1, 3, 2]

Step 2: Each array can be reversed in three ways, giving 9 total outcomes with probability 1/9 each.

Solution Approach

The algorithm uses matrix multiplication to model the probability transitions:

def matmul(a, v, n):
    """Matrix multiplication helper function"""
    result = [0] * n
    for i in range(n):
        for j in range(n):
            result[i] += a[i][j] * v[j]
    return result

def solve(A, p, q):
    n = len(A)
    
    # Calculate swap probabilities
    swp = (n - 3) / (n - 1) if n > 1 else 0
    swapvalp = (pow(swp, p) * (n - 1) + 1) / n
    swapvalm = (1 - pow(swp, p)) / n
    
    # Initialize matrices
    swap_matrix = []
    rev_matrix = []
    dot_vector = []
    
    # Build transition matrices
    for i in range(n):
        swap_row = [swapvalm] * n
        swap_row[i] = swapvalp
        
        rev_row = []
        for j in range(n):
            rev_row.append(2 * (min(i, j, n - i - 1, n - j - 1) + 1) / (n * (n - 1)))
        
        rev_row[i] = 1.0 - 2 * ((i + 1) * (n - i) - min(i + 1, n - i)) / (n * (n - 1))
        
        swap_matrix.append(swap_row)
        rev_matrix.append(rev_row)
        dot_vector.append(2 * ((i + 1) * (n - i) - 1) / (n * (n - 1)))
    
    # Apply operations
    A_float = [float(x) for x in A]
    A_result = matmul(swap_matrix, A_float, n)
    
    for _ in range(q):
        A_result = matmul(rev_matrix, A_result, n)
    
    # Calculate expected value
    total = 0.0
    for i in range(n):
        total += dot_vector[i] * A_result[i]
    
    return round(total, 3)

# Test the function
A = [1, 2, 3]
p = 1
q = 1
result = solve(A, p, q)
print(f"Expected sum: {result}")

Expected sum: 4.667

How It Works

The solution uses transition matrices to model:

• Swap operations: Create a matrix representing swap probabilities after p operations
• Reverse operations: Apply reverse operation matrices q times
• Expected calculation: Use dot product with probability weights to find expected subarray sum

Key Components

Conclusion

This algorithm efficiently calculates expected subarray sums using matrix operations to model probability transitions. The approach handles both swap and reverse operations through careful probability calculations and matrix multiplications.