Given a binary circular array arr[] of size N, the task is to find the minimum swaps to group all 0s together in the array.
Examples:
Input: arr[] = {1, 0, 1, 0, 0, 1, 1}
Output: 1
Explanation: Here are a few of the ways to group all the 0’s together:
- {1, 1, 0, 0, 0, 1, 1} using 1 swap.
- {1, 0, 0, 0, 1, 1, 1} using 1 swap.
- {0, 0, 1, 1, 1, 1, 0} using 2 swaps (using the circular property of the array).
There is no way to group all 0’s together with 0 swaps. Thus, the minimum number of swaps required is 1.
Input: arr[] = {0, 0, 1, 1, 0}
Output: 0
Explanation: All the 0’s are already grouped together due to the circular property of the array.
Thus, the minimum number of swaps required is 0.
Approach: The task can be solved using the sliding window technique. Follow the below steps to solve the problem:
- Count the total number of 0s. Let m be that number
- Find the contiguous region of length m that has the most 0s in it
- The number of 1s in this region is the minimum required swaps. Each swap will move one 0 into the region and one 1 out of the region.
- Finally, use modulo operation for handling the case of the circular arrays.
Below is the implementation of the above approach.
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to count min swap // to get all zeros together int minSwaps( int nums[], int N)
{ int count_1 = 0;
if (N == 1)
return 0;
for ( int i = 0; i < N; i++) {
if (nums[i] == 0)
count_1++;
}
// Window size for counting
// maximum no. of 1s
int windowsize = count_1;
count_1 = 0;
for ( int i = 0; i < windowsize; i++) {
if (nums[i] == 0)
count_1++;
}
// For storing maximum count of 1s in
// a window
int mx = count_1;
for ( int i = windowsize; i < N + windowsize; i++) {
if (nums[i % N] == 0)
count_1++;
if (nums[(i - windowsize) % N] == 0)
count_1--;
mx = max(count_1, mx);
}
return windowsize - mx;
} // Driver code int main()
{ int nums[] = { 1, 0, 1, 0, 0, 1, 1 };
int N = sizeof (nums) / sizeof (nums[0]);
cout << minSwaps(nums, N);
return 0;
} |
// Java program for the above approach import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Function to count min swap
// to get all zeros together
static int minSwaps( int nums[], int N)
{
int count_1 = 0 ;
if (N == 1 )
return 0 ;
for ( int i = 0 ; i < N; i++) {
if (nums[i] == 0 )
count_1++;
}
// Window size for counting
// maximum no. of 1s
int windowsize = count_1;
count_1 = 0 ;
for ( int i = 0 ; i < windowsize; i++) {
if (nums[i] == 0 )
count_1++;
}
// For storing maximum count of 1s in
// a window
int mx = count_1;
for ( int i = windowsize; i < N + windowsize; i++) {
if (nums[i % N] == 0 )
count_1++;
if (nums[(i - windowsize) % N] == 0 )
count_1--;
mx = Math.max(count_1, mx);
}
return windowsize - mx;
}
// Driver code
public static void main (String[] args) {
int nums[] = { 1 , 0 , 1 , 0 , 0 , 1 , 1 };
int N = nums.length;
System.out.println( minSwaps(nums, N));
}
} // This code is contributed by hrithikgarg03188. |
# python3 program for the above approach # Function to count min swap # to get all zeros together def minSwaps(nums, N):
count_1 = 0
if (N = = 1 ):
return 0
for i in range ( 0 , N):
if (nums[i] = = 0 ):
count_1 + = 1
# Window size for counting
# maximum no. of 1s
windowsize = count_1
count_1 = 0
for i in range ( 0 , windowsize):
if (nums[i] = = 0 ):
count_1 + = 1
# For storing maximum count of 1s in
# a window
mx = count_1
for i in range (windowsize, N + windowsize):
if (nums[i % N] = = 0 ):
count_1 + = 1
if (nums[(i - windowsize) % N] = = 0 ):
count_1 - = 1
mx = max (count_1, mx)
return windowsize - mx
# Driver code if __name__ = = "__main__" :
nums = [ 1 , 0 , 1 , 0 , 0 , 1 , 1 ]
N = len (nums)
print (minSwaps(nums, N))
# This code is contributed by rakeshsahni
|
// C# program for the above approach using System;
class GFG
{ // Function to count min swap
// to get all zeros together
static int minSwaps( int []nums, int N)
{
int count_1 = 0;
if (N == 1)
return 0;
for ( int i = 0; i < N; i++) {
if (nums[i] == 0)
count_1++;
}
// Window size for counting
// maximum no. of 1s
int windowsize = count_1;
count_1 = 0;
for ( int i = 0; i < windowsize; i++) {
if (nums[i] == 0)
count_1++;
}
// For storing maximum count of 1s in
// a window
int mx = count_1;
for ( int i = windowsize; i < N + windowsize; i++) {
if (nums[i % N] == 0)
count_1++;
if (nums[(i - windowsize) % N] == 0)
count_1--;
mx = Math.Max(count_1, mx);
}
return windowsize - mx;
}
// Driver code
public static void Main()
{
int []nums = { 1, 0, 1, 0, 0, 1, 1 };
int N = nums.Length;
Console.Write(minSwaps(nums, N));
}
} // This code is contributed by Samim Hossain Mondal. |
<script> // JavaScript code for the above approach
// Function to count min swap
// to get all zeros together
function minSwaps(nums, N) {
let count_1 = 0;
if (N == 1)
return 0;
for (let i = 0; i < N; i++) {
if (nums[i] == 0)
count_1++;
}
// Window size for counting
// maximum no. of 1s
let windowsize = count_1;
count_1 = 0;
for (let i = 0; i < windowsize; i++) {
if (nums[i] == 0)
count_1++;
}
// For storing maximum count of 1s in
// a window
let mx = count_1;
for (let i = windowsize; i < N + windowsize; i++) {
if (nums[i % N] == 0)
count_1++;
if (nums[(i - windowsize) % N] == 0)
count_1--;
mx = Math.max(count_1, mx);
}
return windowsize - mx;
}
// Driver code
let nums = [1, 0, 1, 0, 0, 1, 1];
let N = nums.length;
document.write(minSwaps(nums, N));
// This code is contributed by Potta Lokesh
</script>
|
1
Time Complexity: O(N)
Auxiliary Space: O(1)