最小切换以对二进制数组进行分区，以使其前0到1

给定n个仅包含0和1的整数数组，找到所需的最小切换(从0切换到1，反之亦然)，以使该数组成为分区的数组，即其前0到1。开头至少应有一个0，结尾处可以有零个或多个1。

Input: arr[] = {1, 0, 1, 1, 0}
Output: 2
Toggle the first and last element i.e.,
1 -> 0
0 -> 1
Final array will become:
arr[] = {0 0 1 1 1}
Since first two consecutive elements are all 0s
and rest three consecutive elements are all 1s.
Therefore minimum two toggles are required.

Input: arr[] = {0, 1, 0, 0, 1, 1, 1}
Output: 1

Input: arr[] = {1, 1}
Output: 1
There should be at least one 0.

Input: arr[] = {0, 0}
Output: 0
There can zero 1s.

如果我们观察到这个问题，那么我们将发现肯定存在一个从0到n-1的点，其中到该点的所有元素都应包含全0，指向该点的右元素应包含全1。那些不遵守该法律的索引将被删除。这个想法是从左到右计算全0。

Let zero[i] denotes the number of 0's till ith
index, then for each i, minimum number of
toggles required can be written as: i - zero[i]
 + zero[n] - zero[i] . The part i - zero[i]
indicates number of 1's to be toggled and the 
part zero[n] - zero[i] indicates number of 0's
to be toggled.

After that we just need to take minimum of 
all to get the final answer.

C++

// C++ program to find minimum toggle required
#include 
using namespace std;
  
// Function to calculate minimum toggling
// required by using Dynamic programming
int minToggle(int arr[], int n)
{
    int zero[n + 1];
    zero[0] = 0;
  
    // Fill entries in zero[] such that zero[i]
    // stores count of zeroes to the left of i
    // (exl
    for (int i = 1; i <= n; ++i) {
        // If zero found update zero[] array
        if (arr[i - 1] == 0)
            zero[i] = zero[i - 1] + 1;
        else
            zero[i] = zero[i - 1];
    }
  
    // Finding the minimum toggle required from
    // every index(0 to n-1)
    int ans = n;
    for (int i = 1; i <= n; ++i)
        ans = min(ans, i - zero[i] + zero[n] - zero[i]);
  
    return ans;
}
  
// Driver Program
int main()
{
    int arr[] = { 1, 0, 1, 1, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << minToggle(arr, n) << "\n";
    return 0;
}

Java

// Java program to find minimum
// toggle required
import java.io.*;
  
class GFG {
  
    // Function to calculate minimum toggling
    // required by using Dynamic programming
    static int minToggle(int arr[], int n)
    {
        int zero[] = new int[n + 1];
        zero[0] = 0;
  
        // Fill entries in zero[] such that
        // zero[i] stores count of zeroes
        // to the left of i (exl
        for (int i = 1; i <= n; ++i) {
            // If zero found update zero[] array
            if (arr[i - 1] == 0)
                zero[i] = zero[i - 1] + 1;
            else
                zero[i] = zero[i - 1];
        }
  
        // Finding the minimum toggle required
        // from every index(0 to n-1)
        int ans = n;
        for (int i = 1; i <= n; ++i)
            ans = Math.min(ans, i - zero[i] + zero[n]
                                    - zero[i]);
  
        return ans;
    }
  
    // Driver Program
    public static void main(String[] args)
    {
        int arr[] = { 1, 0, 1, 1, 0 };
        int n = arr.length;
        System.out.println(minToggle(arr, n));
    }
}
  
// This code is contributed by vt_m.

Python3

# Python program to find
# minimum toggle required
  
# Function to calculate
# minimum toggling
# required by using
# Dynamic programming
def minToggle(arr, n):
  
    zero =[0 for i in range(n + 1+1)]
    zero[0] = 0
   
    # Fill entries in zero[]
    # such that zero[i]
    # stores count of zeroes
    # to the left of i
    # (exl
    for i in range(1, n + 1):
      
        # If zero found
        # update zero[] array
        if (arr[i-1] == 0):
            zero[i] = zero[i-1] + 1
        else:
            zero[i] = zero[i-1]
   
    # Finding the minimum
    # toggle required from
    # every index(0 to n-1)
    ans = n
    for i in range(1, n + 1):
        ans = min(ans, i - zero[i] + zero[n] - zero[i])
   
    return ans
      
# Driver Program
  
arr = [1, 0, 1, 1, 0]
n = len(arr)
  
print(minToggle(arr, n))
  
# This code is contributed
# by Anant Agarwal.

C#

// C# program to find minimum
// toggle required
using System;
  
class GFG {
  
    // Function to calculate minimum toggling
    // required by using Dynamic programming
    static int minToggle(int[] arr, int n)
    {
          
        int[] zero = new int[n + 1];
        zero[0] = 0;
  
        // Fill entries in zero[] such that
        // zero[i] stores count of zeroes
        // to the left of i (exl
        for (int i = 1; i <= n; ++i) {
              
            // If zero found update zero[]
            // array
            if (arr[i - 1] == 0)
                zero[i] = zero[i - 1] + 1;
            else
                zero[i] = zero[i - 1];
        }
  
        // Finding the minimum toggle required
        // from every index(0 to n-1)
        int ans = n;
          
        for (int i = 1; i <= n; ++i)
            ans = Math.Min(ans, i - zero[i] +
                            zero[n] - zero[i]);
  
        return ans;
    }
  
    // Driver Program
    public static void Main()
    {
        int[] arr = { 1, 0, 1, 1, 0 };
        int n = arr.Length;
          
        Console.WriteLine(minToggle(arr, n));
    }
}
  
// This code is contributed by Sam007.

输出：

2

时间复杂度： O(n)
辅助空间： O(n)