# Minimum number of steps required to place all 1s at a single index

• Last Updated : 22 Dec, 2021

Given a binary array A[] of size N, where all 1s can be moved to its adjacent position, the task is to print an array res[] of size N, where res[i] contains the minimum number of steps required to move all the 1s at the ith index.

Examples:

Input: A[] = {1, 0, 1, 0}
Output: {2, 2, 2, 4}
Explanation:
For i = 0, moving all 1s to 0th index requires 2 steps, i.e abs(0 – 0) + abs(0 – 2) = 2.
For i = 1, moving all 1s to 1st index requires 2 steps, i.e abs(1 – 0) + abs(1 – 2) = 2.
For i = 2, moving all 1s to 2nd index requires 2 steps, i.e abs(2 – 0) + abs(2 – 2) = 2.
For i = 3, moving all 1’s to 3rd index requires 4 steps, i.e abs(3 – 0) + abs(3 – 2) = 4.
Hence, res[] is {2, 2, 2, 4}

Input: A[] = {0, 0, 1, 0, 0, 1}
Output: {7, 5, 3, 3, 3, 3}
Explanation:
For i = 0, moving all 1s to 0th index requires 7 steps, i.e abs(2 – 0) + abs(5 – 0) = 7.
For i = 1, moving all 1s to 1st index requires 5 steps, i.e abs(2 – 1) + abs(5 – 1) = 5.
For i = 2, moving all 1s to 2nd index requires 3 steps, i.e abs(2 – 2) + abs(5 – 2) = 3.
For i = 3, moving all 1s to 3rd index will take 3 steps, i.e abs(2 – 2) + abs(5 – 3) = 3.
For i = 4, moving all 1s to 4th index will take 3 steps, i.e abs(2 – 4) + abs(5 – 4) = 3.
For i = 5, moving all 1s to 5th index will take 3 steps, i.e abs(2 – 5) + abs(5 – 5) = 3.
Hence, res[] is {7, 5, 3, 3, 3, 3}

Naive Approach: Follow the steps to solve the problem :

1. Traverse the array.
2. For every ith index, count the number of steps required to move all 1s to the ith index.
3. Iterate over the range [0, N – 1], using a variable, say i.
• Initialize steps = 0.
• Iterate over the range [0, N – 1], using a variable j.
• If A[j] is equal to 1, add abs(i – j) to steps.
4. Print the minimum number of steps.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Prefix Sum. Follow the steps below to solve this problem:

1. Traverse the array.
2. Initialize an array, say left[], and initialize count = A.
3. Iterate over the range [1, N – 1], and update left[i] = left[i – 1] + count, where count is the number of 1s on the left side of i.
4. Initialize an array, say right[], and initialize count = A[N – 1].
5. Iterate over the range [N – 2, 0], and update right[i] = right[i + 1] + count, where count is the number of 1s on the right side of i.
6. Calculate and update the final answer in res[], where res[i] is the sum of the steps from left and right sides, i.e res[i] = right[i] + left[i]
7. Print the array res[].

Below is the implementation of the above approach:

## C++

 `// C++ implementation of``// the above approach``#include ``using` `namespace` `std;` `// Function to print minimum steps``// required to shift all 1s to a``// single index in a binary array``void` `minsteps(vector<``int``>& A)``{``    ``// Size of array``    ``int` `n = A.size();` `    ``// Used to store cumulative sum``    ``vector<``int``> left(n, 0), right(n, 0), res(n, 0);` `    ``// Initialize count``    ``int` `count = A;` `    ``// Traverse the array in``    ``// forward direction``    ``for` `(``int` `i = 1; i < n; i++) {``        ``// Steps needed to store all``        ``// previous ones to ith index``        ``left[i] = left[i - 1] + count;` `        ``// Count number of 1s``        ``// present till i-th index``        ``count += A[i];``    ``}` `    ``// Initialize count``    ``count = A[n - 1];` `    ``// Traverse the array in``    ``// backward direction``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``        ``// Steps needed to store all 1s to``        ``// the right of i at current index``        ``right[i] = right[i + 1] + count;` `        ``// Count number of 1s``        ``// present after i-th index``        ``count += A[i];``    ``}` `    ``// Print the number of steps required``    ``for` `(``int` `i = 0; i < n; i++) {``        ``res[i] = left[i] + right[i];``        ``cout << res[i] << ``" "``;``    ``}``    ``cout << ``"\n"``;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> A = { 1, 0, 1, 0 };``    ``minsteps(A);``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;``class` `GFG``{` `  ``// Function to print minimum steps``  ``// required to shift all 1s to a``  ``// single index in a binary array``  ``static` `void` `minsteps(``int``[] A)``  ``{``    ` `    ``// Size of array``    ``int` `n = A.length;` `    ``// Used to store cumulative sum``    ``int``[] left = ``new` `int` `[n];``    ``Arrays.fill(left, ``0``);``    ``int``[] right = ``new` `int` `[n];``    ``Arrays.fill(right, ``0``);``    ``int``[] res = ``new` `int` `[n];``    ``Arrays.fill(res, ``0``);` `    ``// Initialize count``    ``int` `count = A[``0``];` `    ``// Traverse the array in``    ``// forward direction``    ``for` `(``int` `i = ``1``; i < n; i++) {``      ``// Steps needed to store all``      ``// previous ones to ith index``      ``left[i] = left[i - ``1``] + count;` `      ``// Count number of 1s``      ``// present till i-th index``      ``count += A[i];``    ``}` `    ``// Initialize count``    ``count = A[n - ``1``];` `    ``// Traverse the array in``    ``// backward direction``    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) {``      ``// Steps needed to store all 1s to``      ``// the right of i at current index``      ``right[i] = right[i + ``1``] + count;` `      ``// Count number of 1s``      ``// present after i-th index``      ``count += A[i];``    ``}` `    ``// Print the number of steps required``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``res[i] = left[i] + right[i];``      ``System.out.print(res[i] + ``" "``);``    ``}``    ``System.out.println();``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] A = { ``1``, ``0``, ``1``, ``0` `};``    ``minsteps(A);``  ``}``}` `// This code is contributed by souravghosh0416.`

## Python3

 `# Python3 implementation of``# the above approach` `# Function to print minimum steps``# required to shift all 1s to a``# single index in a binary array``def` `minsteps(A):``  ` `    ``# Size of array``    ``n ``=` `len``(A)` `    ``# Used to store cumulative sum``    ``left, right, res ``=``[``0``]``*``n, [``0``]``*``n, [``0``]``*``n` `    ``# Initialize count``    ``count ``=` `A[``0``]` `    ``# Traverse the array in``    ``# forward direction``    ``for` `i ``in` `range``(``1``, n):``      ` `        ``# Steps needed to store all``        ``# previous ones to ith index``        ``left[i] ``=` `left[i ``-` `1``] ``+` `count` `        ``# Count number of 1s``        ``# present till i-th index``        ``count ``+``=` `A[i]` `    ``# Initialize count``    ``count ``=` `A[n ``-` `1``]` `    ``# Traverse the array in``    ``# backward direction``    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``):``      ` `        ``# Steps needed to store all 1s to``        ``# the right of i at current index``        ``right[i] ``=` `right[i ``+` `1``] ``+` `count` `        ``# Count number of 1s``        ``# present after i-th index``        ``count ``+``=` `A[i]` `    ``# Print the number of steps required``    ``for` `i ``in` `range``(n):``        ``res[i] ``=` `left[i] ``+` `right[i]``        ``print``(res[i], end ``=` `" "``)``    ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``A ``=` `[``1``, ``0``, ``1``, ``0``]``    ``minsteps(A)` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG``{``  ` `  ``// Function to print minimum steps``  ``// required to shift all 1s to a``  ``// single index in a binary array``  ``static` `void` `minsteps(``int``[] A)``  ``{` `    ``// Size of array``    ``int` `n = A.Length;` `    ``// Used to store cumulative sum``    ``int``[] left = ``new` `int` `[n];``    ``for` `(``int` `i = 1; i < n; i++) {``      ``left[i] = 0;``    ``}` `    ``int``[] right = ``new` `int` `[n];``    ``for` `(``int` `i = 1; i < n; i++) {``      ``right[i] = 0;``    ``}` `    ``int``[] res = ``new` `int` `[n];``    ``for` `(``int` `i = 1; i < n; i++) {``      ``res[i] = 0;``    ``}` `    ``// Initialize count``    ``int` `count = A;` `    ``// Traverse the array in``    ``// forward direction``    ``for` `(``int` `i = 1; i < n; i++) {``      ``// Steps needed to store all``      ``// previous ones to ith index``      ``left[i] = left[i - 1] + count;` `      ``// Count number of 1s``      ``// present till i-th index``      ``count += A[i];``    ``}` `    ``// Initialize count``    ``count = A[n - 1];` `    ``// Traverse the array in``    ``// backward direction``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``      ``// Steps needed to store all 1s to``      ``// the right of i at current index``      ``right[i] = right[i + 1] + count;` `      ``// Count number of 1s``      ``// present after i-th index``      ``count += A[i];``    ``}` `    ``// Print the number of steps required``    ``for` `(``int` `i = 0; i < n; i++) {``      ``res[i] = left[i] + right[i];``      ``Console.Write(res[i] + ``" "``);``    ``}``    ``Console.WriteLine();``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] A = { 1, 0, 1, 0 };``    ``minsteps(A);``  ``}``}` `// This code is contributed by susmitakundugoaldanga.`

## Javascript

 ``
Output:
`2 2 2 4`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up