```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	var n int
	fmt.Fscan(reader, &n)
	
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}
	
	// Collect occupied and free positions
	occupied := []int{}
	free := []int{}
	
	for i := 0; i < n; i++ {
		if a[i] == 1 {
			occupied = append(occupied, i)
		} else {
			free = append(free, i)
		}
	}
	
	m := len(occupied)
	k := len(free)
	
	// dp[i][j] = min cost to assign first i occupied chairs to some j free chairs
	// We need to assign each occupied chair to a distinct free chair
	// Classic DP: dp[i][j] = min cost matching first i occupied with first j free
	// dp[i][j] = min(dp[i][j-1], dp[i-1][j-1] + |occupied[i-1] - free[j-1]|)
	
	const INF = int(1e18)
	
	// dp[i][j]: matched i people to j free seats (j >= i)
	dp := make([][]int, m+1)
	for i := 0; i <= m; i++ {
		dp[i] = make([]int, k+1)
		for j := 0; j <= k; j++ {
			dp[i][j] = INF
		}
	}
	dp[0][0] = 0
	
	for j := 0; j <= k; j++ {
		dp[0][j] = 0
	}
	
	for i := 1; i <= m; i++ {
		for j := i; j <= k; j++ {
			// Don't use free[j-1] for person i
			if dp[i][j-1] < INF {
				dp[i][j] = dp[i][j-1]
			}
			// Use free[j-1] for person i (occupied[i-1])
			if dp[i-1][j-1] < INF {
				cost := dp[i-1][j-1] + abs(occupied[i-1]-free[j-1])
				if cost < dp[i][j] {
					dp[i][j] = cost
				}
			}
		}
	}
	
	fmt.Println(dp[m][k])
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}
```