<p>A <strong>swap</strong> is defined as taking two <strong>distinct</strong> positions in an array and swapping the values in them.</p>

<p>A <strong>circular</strong> array is defined as an array where we consider the <strong>first</strong> element and the <strong>last</strong> element to be <strong>adjacent</strong>.</p>

<p>Given a <strong>binary</strong> <strong>circular</strong> array <code>nums</code>, return <em>the minimum number of swaps required to group all </em><code>1</code><em>&#39;s present in the array together at <strong>any location</strong></em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,1,0,1,1,0,0]
<strong>Output:</strong> 1
<strong>Explanation:</strong> Here are a few of the ways to group all the 1&#39;s together:
[0,<u>0</u>,<u>1</u>,1,1,0,0] using 1 swap.
[0,1,<u>1</u>,1,<u>0</u>,0,0] using 1 swap.
[1,1,0,0,0,0,1] using 2 swaps (using the circular property of the array).
There is no way to group all 1&#39;s together with 0 swaps.
Thus, the minimum number of swaps required is 1.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [0,1,1,1,0,0,1,1,0]
<strong>Output:</strong> 2
<strong>Explanation:</strong> Here are a few of the ways to group all the 1&#39;s together:
[1,1,1,0,0,0,0,1,1] using 2 swaps (using the circular property of the array).
[1,1,1,1,1,0,0,0,0] using 2 swaps.
There is no way to group all 1&#39;s together with 0 or 1 swaps.
Thus, the minimum number of swaps required is 2.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,1,0,0,1]
<strong>Output:</strong> 0
<strong>Explanation:</strong> All the 1&#39;s are already grouped together due to the circular property of the array.
Thus, the minimum number of swaps required is 0.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
</ul>

class Solution:
    def __init__(self):
        self.sk = SolutionK()

    def minSwaps(self, nums: List[int]) -> int:
        return self.sk.minSwaps(nums)


class SolutionK:
    # Approach:
    # We should bring together the 1s where they are most dense (== fewer 0s).
    # That will minimize the number of swaps.
    # - pass 1 : count number of 1s
    # - pass 2 : find the densest location
    #   given that the array is circular, collecting all 0s together in the center
    #   is the same as collecting all 1s near the ends.
    def minSwaps(self, n: List[int]) -> int:
        N = len(n)

        # We use cumulative count of 1s to make it efficient to compute
        # the number of 1s in a given range.
        count1s = []
        count = 0

        for nn in n:
            if nn == 1:
                count += 1
            count1s.append(count)

        def get1Count(i, j):
            return count1s[j] - count1s[i]

        def get0Count(i, j):
            num1s = get1Count(i, j)
            return j - i - num1s

        num_1s = count1s[-1]
        num_0s = N - num_1s

        # Scan the array and identify the best location of 1s and 0s to collect.
        best1_count = 0
        best0_count = 0

        for i in range(N - num_1s):
            num1s = get1Count(i, i + num_1s)
            best1_count = max(best1_count, num1s)

        for i in range(N - num_0s):
            num0s = get0Count(i, i + num_0s)
            best0_count = max(best0_count, num0s)

        swaps1 = num_1s - best1_count
        swaps0 = num_0s - best0_count

        result = min(swaps0, swaps1)
        return result

22700