📌  相关文章
📜  将二进制数组的所有元素转换为K所需的最小子数组翻转

📅  最后修改于: 2021-04-21 23:18:01             🧑  作者: Mango

给定一个由N个整数组成的二进制数组arr [] ,任务是计算转换该数组的所有元素等于K所需的以下类型的最小操作数:

  • 从给定的数组中选择任何索引X。
  • 翻转子数组arr [X]…arr [N – 1]的所有元素,即,如果arr [i] = 1,则将arr [i]设置为0,反之亦然。

例子:

处理方法:将观察以下情况:

请按照以下步骤解决以上问题:

  1. 将变量标志初始化为K的倒数。即,如果K = 0,则为1,反之亦然,即当前值。
  2. 将变量cnt初始化为0,该变量将使数组arr []中的更改点数保持计数。
  3. 遍历数组arr [] ,对于每个索引,执行以下步骤:
    • 如果标志值和arr [i]值不同,请转到下一个迭代。
    • 如果标志arr [i]相等,则增加计数并将标志设置为标志=(标志+ 1)%2
  4. 打印count的最终值。

下面是上述方法的实现:

C++14
// C++14 Program to implement 
// the above appraoch 
#include  
using namespace std; 
  
// Function to count the minimum 
// number of subarray flips required 
int minSteps(int arr[], int n, int k) 
{ 
    int i, cnt = 0; 
    int flag; 
    if (k == 1) 
        flag = 0; 
    else
        flag = 1; 
  
    // Iterate the array 
    for (i = 0; i < n; i++) { 
  
        // If arr[i] and flag are equal 
        if (arr[i] == flag) { 
            cnt++; 
            flag = (flag + 1) % 2; 
        } 
    } 
  
    // Return the answer 
    return cnt; 
} 
  
// Driver Code 
int main() 
{ 
    int arr[] = { 1, 0, 1, 0, 0, 1, 1, 1 }; 
    int n = sizeof(arr) 
            / sizeof(arr[0]); 
    int k = 1; 
  
    cout << minSteps(arr, n, k); 
  
    return 0; 
}


Java
// Java program to implement 
// the above approach 
import java.util.*; 
  
class GFG{ 
  
// Function to count the minimum 
// number of subarray flips required 
static int minSteps(int arr[], int n, int k) 
{ 
    int i, cnt = 0; 
    int flag; 
      
    if (k == 1) 
        flag = 0; 
    else
        flag = 1; 
  
    // Iterate the array 
    for(i = 0; i < n; i++) 
    { 
  
        // If arr[i] and flag are equal 
        if (arr[i] == flag) 
        { 
            cnt++; 
            flag = (flag + 1) % 2; 
        } 
    } 
  
    // Return the answer 
    return cnt; 
} 
  
// Driver code 
public static void main (String[] args) 
{ 
    int arr[] = { 1, 0, 1, 0, 0, 1, 1, 1 }; 
    int n = arr.length; 
    int k = 1; 
      
    System.out.print(minSteps(arr, n, k)); 
} 
} 
  
// This code is contributed by offbeat


Python3
# Python3 program to implement 
# the above approach 
  
# Function to count the minimum 
# number of subarray flips required 
def minSteps(arr, n, k): 
  
    cnt = 0
    if(k == 1): 
        flag = 0
    else: 
        flag = 1
  
    # Iterate the array 
    for i in range(n): 
  
        # If arr[i] and flag are equal 
        if(arr[i] == flag): 
            cnt += 1
            flag = (flag + 1) % 2
  
    # Return the answer 
    return cnt 
  
# Driver Code 
arr = [ 1, 0, 1, 0, 0, 1, 1, 1 ] 
n = len(arr) 
k = 1
  
# Function call 
print(minSteps(arr, n, k)) 
  
# This code is contributed by Shivam Singh


C#
// C# program to implement 
// the above approach 
using System;
  
class GFG{
  
// Function to count the minimum
// number of subarray flips required
static int minSteps(int[] arr, int n, int k)
{
    int i, cnt = 0;
    int flag;
      
    if (k == 1)
        flag = 0;
    else
        flag = 1;
  
    // Iterate the array
    for(i = 0; i < n; i++) 
    {
          
        // If arr[i] and flag are equal
        if (arr[i] == flag) 
        {
            cnt++;
            flag = (flag + 1) % 2;
        }
    }
  
    // Return the answer
    return cnt;
}
  
// Driver code
public static void Main () 
{
    int[] arr = { 1, 0, 1, 0, 0, 1, 1, 1 };
    int n = arr.Length;
    int k = 1;
      
    Console.Write(minSteps(arr, n, k));
}
}
  
// This code is contributed by chitranayal


输出:
4

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