可能的最大翻转使得没有一对相邻元素都是 1

给定一个大小为N的二进制数组arr[] ，任务是找到可以转换为1的0 s 的最大计数，使得没有一对相邻的数组元素为1 。

例子：

Input: arr[] = { 1, 0, 0, 0, 1 }
Output: 1
Explanation:
Updating arr[2] to 1 modifies arr[] to { 1, 0, 1, 0, 1 }
Therefore, the required output is 1

Input: arr[] = { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }
Output: 3
Explanation:
Updating arr[0], arr[5] and arr[9] modifies arr[] to { 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 }
Therefore, the required output is 3

编程需要懂一点英语

方法：该问题可以使用贪心技术解决。请按照以下步骤解决问题：

在数组的前端和末尾插入0 。
遍历数组，arr[]。在每个第i次迭代，检查是否ARR [I]，ARR第[i + 1]和常用3第[i + 2]是0秒或没有。如果发现为真，则增加计数并更新arr[i + 1] = 1 。
最后，打印获得的计数。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the maximum count of 0s
// required to be converted into 1s such
// no pair of adjacent elements are 1
void maxPositionsOccupied(vector& arr)
{
 
    // Base Case
    if (arr.size() == 0) {
        cout << 0;
        return;
    }
 
    // Insert 0 at the end
    // of the array
    arr.push_back(0);
 
    // Insert 0 at the front
    // of the array
    arr.insert(arr.begin(), 0);
 
    // Stores the maximum count of of 0s
    // that can be converted into 1s
    int ans = 0;
 
    // Stores index of array elements
    int i = 0;
 
    // Traverse the array
    while ((i < arr.size() - 2)) {
 
        // If adjacent elements are 0s
        if ((arr[i] == 0) && (arr[i + 1] == 0)
            && (arr[i + 2] == 0)) {
 
            // Update ans
            ans++;
 
            // Update arr[i + 1]
            arr[i + 1] = 1;
        }
 
        // Update i
        i++;
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver Code
int main()
{
    // Given binary array
    vector arr = { 1, 0, 0, 0, 1 };
 
    // Prints the maximum 0 to 1
    // conversions required
    maxPositionsOccupied(arr);
 
    return 0;
}

Java

// Java program for the above approach
public class GFG
{
 
  // Function to find the maximum count of 0s
  // required to be converted into 1s such
  // no pair of adjacent elements are 1
  static void maxPositionsOccupied(int[] arr)
  {
 
    // Base Case
    if (arr.length == 0)
    {
      System.out.print(0);
      return;
    }
 
    // Stores the maximum count of of 0s
    // that can be converted into 1s
    int ans = 0;
 
    // Stores index of array elements
    int i = 0;
 
    // Traverse the array
    while ((i < arr.length - 2))
    {
 
      // If adjacent elements are 0s
      if ((arr[i] == 0) &&
          (arr[i + 1] == 0) &&
          (arr[i + 2] == 0))
      {
 
        // Update ans
        ans++;
 
        // Update arr[i + 1]
        arr[i + 1] = 1;
      }
 
      // Update i
      i++;
    }
 
    // Print the answer
    System.out.print(ans);
  }
 
  // Driver code
  public static void main(String[] args)
  {
 
    // Given binary array
    int[] arr = { 1, 0, 0, 0, 1 };
 
    // Prints the maximum 0 to 1
    // conversions required
    maxPositionsOccupied(arr);
  }
}
 
// This code is contributed by divyeshrabadiya07.

Python3

# Python3 program for the above approach
 
# Function to find the maximum count of 0s
# required to be converted into 1s such
# no pair of adjacent elements are 1
def maxPositionsOccupied(arr):
     
    # Base Case
    if (len(arr) == 0):
        print(0)
 
    # Insert 0 at the end
    # of the array
    arr.append(0)
 
    # Insert 0 at the front
    # of the array
    arr.insert(0, 0)
 
    # Stores the maximum count of of 0s
    # that can be converted into 1s
    ans = 0
 
    # Stores index of array elements
    i = 0
 
    # Traverse the array
    while((i < len(arr) - 2)):
         
        # If adjacent elements are 0s
        if ((arr[i] == 0) and
            (arr[i + 1] == 0) and
            (arr[i + 2] == 0)):
 
            # Update ans
            ans += 1
 
            # Update arr[i + 1]
            arr[i + 1] = 1
 
        # Update i
        i += 1
 
    # Print the answer
    print(ans)
 
# Driver Code
if __name__ == '__main__':
     
    # Given binary array
    arr =  [ 1, 0, 0, 0, 1 ]
 
    # Prints the maximum 0 to 1
    # conversions required
    maxPositionsOccupied(arr)
 
# This code is contributed by SURENDRA_GANGWAR

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the maximum count of 0s
// required to be converted into 1s such
// no pair of adjacent elements are 1
static void maxPositionsOccupied(int[] arr)
{
     
    // Base Case
    if (arr.Length == 0)
    {
        Console.Write(0);
        return;
    }
     
    // Stores the maximum count of of 0s
    // that can be converted into 1s
    int ans = 0;
   
    // Stores index of array elements
    int i = 0;
   
    // Traverse the array
    while ((i < arr.Length - 2))
    {
         
        // If adjacent elements are 0s
        if ((arr[i] == 0) &&
            (arr[i + 1] == 0) &&
            (arr[i + 2] == 0))
        {
             
            // Update ans
            ans++;
             
            // Update arr[i + 1]
            arr[i + 1] = 1;
        }
         
        // Update i
        i++;
    }
     
    // Print the answer
    Console.Write(ans);
}  
 
// Driver code
static void Main()
{
     
    // Given binary array
    int[] arr = { 1, 0, 0, 0, 1 };
     
    // Prints the maximum 0 to 1
    // conversions required
    maxPositionsOccupied(arr);
}
}
 
// This code is contributed by divyesh072019

Javascript

输出：

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。