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

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 i^th index.

Examples:

Input: A[] = {1, 0, 1, 0}
Output: {2, 2, 2, 4}
Explanation: 
For i = 0, moving all 1s to 0^th index requires 2 steps, i.e abs(0 – 0) + abs(0 – 2) = 2.
For i = 1, moving all 1s to 1^st index requires 2 steps, i.e abs(1 – 0) + abs(1 – 2) = 2.
For i = 2, moving all 1s to 2^nd index requires 2 steps, i.e abs(2 – 0) + abs(2 – 2) = 2.
For i = 3, moving all 1’s to 3^rd 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 0^th index requires 7 steps, i.e abs(2 – 0) + abs(5 – 0) = 7.
For i = 1, moving all 1s to 1^st index requires 5 steps, i.e abs(2 – 1) + abs(5 – 1) = 5.
For i = 2, moving all 1s to 2^nd 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 4^th index will take 3 steps, i.e abs(2 – 4) + abs(5 – 4) = 3.
For i = 5, moving all 1s to 5^th 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 i^th index, count the number of steps required to move all 1s to the i^th 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(N²)
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[0].
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 <bits/stdc++.h>
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[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];
        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[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];
      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

<script>

// JavaScript program to implement
// the above approach

  // Function to print minimum steps
  // required to shift all 1s to a
  // single index in a binary array
  function minsteps(A)
  {

    // Size of array
    let n = A.length;

    // Used to store cumulative sum
    let left = Array.from({length: n}, (_, i) => 0);
    let right = Array.from({length: n}, (_, i) => 0);
    let res = Array.from({length: n}, (_, i) => 0);

    // Initialize count
    let count = A[0];

    // Traverse the array in
    // forward direction
    for (let 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 (let 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 (let i = 0; i < n; i++) {
      res[i] = left[i] + right[i];
      document.write(res[i] + " ");
    }
    document.write("<br/>");
  }

// Driver code
    let A = [ 1, 0, 1, 0 ];
    minsteps(A);

// This code is contributed by sanjoy_62.
</script>

Output:

2 2 2 4

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