Sliding Window Maximum : Set 2

Set 1: Sliding Window Maximum (Maximum of all subarrays of size k).
Given an array arr of size N and an integer K, the task is to find the maximum for each and every contiguous subarray of size K.

Examples:

Input: arr[] = {1, 2, 3, 1, 4, 5, 2, 3, 6}, K = 3 
Output: 3 3 4 5 5 5 6 
All contiguous subarrays of size k are 
{1, 2, 3} => 3 
{2, 3, 1} => 3 
{3, 1, 4} => 4 
{1, 4, 5} => 5 
{4, 5, 2} => 5 
{5, 2, 3} => 5 
{2, 3, 6} => 6

Input: arr[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13}, K = 4 
Output: 10 10 10 15 15 90 90  

Approach: To solve this in lesser space complexity we can use two pointer technique.  

• The first variable pointer iterates through the subarray and finds the maximum element of a given size K
• The second variable pointer marks the ending index of the first variable pointer i.e., (i + K – 1)th index.
• When the first variable pointer reaches the index of the second variable pointer, the maximum of that subarray has been computed and will be printed.
• The process is repeated until the second variable pointer reaches the last array index (i.e array_size – 1).

Below is the implementation of the above approach: 

C++

// C++ program to find the maximum for each
// and every contiguous subarray of size K

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum for each
// and every contiguous subarray of size k
void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            cout << a[i] << " ";
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            cout << max << " ";
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code
int main()
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = sizeof(a) / sizeof(a[0]);
    int K = 3;

    printKMax(a, n, K);

    return 0;
}

Java

// Java program to find the maximum for each
// and every contiguous subarray of size K
import java.util.*;

class GFG{

// Function to find the maximum for each
// and every contiguous subarray of size k
static void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            System.out.print(a[i]+ " ");
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            System.out.print(max+ " ");
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code
public static void main(String[] args)
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = a.length;
    int K = 3;

    printKMax(a, n, K);
}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 program to find the maximum for each
# and every contiguous subarray of size K

# Function to find the maximum for each
# and every contiguous subarray of size k
def printKMax(a, n, k):

    # If k = 1, print all elements
    if (k == 1):
        for i in range(n):
            print(a[i], end=" ");
        return;

    # Using p and q as variable pointers
    # where p iterates through the subarray
    # and q marks end of the subarray.
    p = 0;
    q = k - 1;
    t = p;
    max = a[k - 1];

    # Iterating through subarray.
    while (q <= n - 1):

        # Finding max
        # from the subarray.
        if (a[p] > max):
            max = a[p];
        p += 1;

        # Printing max of subarray
        # and shifting pointers
        # to next index.
        if (q == p and p != n):
            print(max, end=" ");
            q += 1;
            p = t + 1;
            t = p;

            if (q < n):
                max = a[q];

# Driver Code
if __name__ == '__main__':
    a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    n = len(a);
    K = 3;

    printKMax(a, n, K);

# This code is contributed by Princi Singh

C#

// C# program to find the maximum for each
// and every contiguous subarray of size K
using System;

class GFG{

// Function to find the maximum for each
// and every contiguous subarray of size k
static void printKMax(int []a, int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            Console.Write(a[i]+ " ");
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            Console.Write(max+ " ");
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code
public static void Main(String[] args)
{
    int []a = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = a.Length;
    int K = 3;

    printKMax(a, n, K);
}
}

// This code is contributed by Rajput-Ji

Javascript

<script>
// Javascript program to find the maximum for each
// and every contiguous subarray of size K

// Function to find the maximum for each
// and every contiguous subarray of size k
function printKMax(a, n, k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (let i = 0; i < n; i += 1)
            document.write(a[i] + " ");
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    let p = 0, q = k - 1, t = p, max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            document.write(max + " ");
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code

let a = [ 1, 2, 3, 4, 5,
            6, 7, 8, 9, 10 ];
let n = a.length
let K = 3;

printKMax(a, n, K);
</script>

Output

3 4 5 6 7 8 9 10 

Time Complexity: O(N*k) 
Auxiliary Space Complexity: O(1)

Approach 2: Using Dynamic Programming:

• Firstly, divide the entire array into blocks of k elements such that each block contains k elements of the array(not always for the last block).
• Maintain two dp arrays namely, left and right.
• left[i] is the maximum of all elements that are to the left of current element(including current element) in the current block(block in which current element is present).
• Similarly, right[i] is the maximum of all elements that are to the right of current element(including current element) in the current block(block in which current element is present).
• Finally, when calculating the maximum element in any subarray of length k, we calculate the maximum of right[l] and left[r]
  where l = starting index of current sub array, r = ending index of current sub array

Below is the implementation of above approach,

C++

// C++ program to find the maximum for each
// and every contiguous subarray of size K

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum for each
// and every contiguous subarray of size k
void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            cout << a[i] << " ";
        return;
    }

      //left[i] stores the maximum value to left of i in the current block
      //right[i] stores the maximum value to the right of i in the current block
    int left[n],right[n];

      for(int i=0;i<n;i++){
          //if the element is starting element of that block
        if(i%k == 0) left[i] = a[i];
          else left[i] = max(left[i-1],a[i]);

          //if the element is ending element of that block
          if((n-i)%k == 0 || i==0) right[n-1-i] = a[n-1-i];
          else right[n-1-i] = max(right[n-i],a[n-1-i]);
    }

      for(int i=0,j=k-1; j<n; i++,j++)
         cout << max(left[j],right[i]) << ' ';
}

// Driver Code
int main()
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = sizeof(a) / sizeof(a[0]);
    int K = 3;

    printKMax(a, n, K);

    return 0;
}

Java

// Java program to find the maximum for each
// and every contiguous subarray of size K
import java.util.*;

class GFG
{

  // Function to find the maximum for each
  // and every contiguous subarray of size k
  static void printKMax(int a[], int n, int k)
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (int i = 0; i < n; i += 1)
        System.out.print(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    int left[] = new int[n];
    int right[] = new int[n];

    for (int i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.max(right[n - i], a[n - 1 - i]);
    }

    for (int i = 0, j = k - 1; j < n; i++, j++)
      System.out.print(Math.max(left[j], right[i]) + " ");
  }

  // Driver Code
  public static void main(String[] args)
  {
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int n = a.length;
    int K = 3;

    printKMax(a, n, K);

  }
}

// This code is contributed by gauravrajput1

Python3

# Python3 program to find the maximum for each
# and every contiguous subarray of size K
# Function to find the maximum for each
# and every contiguous subarray of size k
def printKMax(a, n, k):

    # If k = 1, print all elements
    if (k == 1):
        for i in range(n):
            print(a[i],end = " ")
        return

    # left[i] stores the maximum value to left of i in the current block
    # right[i] stores the maximum value to the right of i in the current block
    left = [ 0 for i in range(n)]
    right = [ 0 for i in range(n)]

    for i in range(n):

        # if the element is starting element of that block
        if (i % k == 0):
            left[i] = a[i]
        else:
            left[i] = max(left[i - 1], a[i])

        # if the element is ending element of that block
        if ((n - i) % k == 0 or i == 0):
            right[n - 1 - i] = a[n - 1 - i]
        else:
            right[n - 1 - i] = max(right[n - i], a[n - 1 - i])

    i = 0
    j = k - 1

    while j < n:
        print(max(left[j], right[i]),end = " ")
        i += 1
        j += 1

# Driver Code
a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
n = len(a)
K = 3

printKMax(a, n, K)

# This code is contributed by shinjanpatra

C#

// C# program to find the maximum for each
// and every contiguous subarray of size K
using System;

class GFG
{

  // Function to find the maximum for each
  // and every contiguous subarray of size k
  static void printKMax(int []a, int n, int k)
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (int i = 0; i < n; i += 1)
        Console.Write(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    int []left = new int[n];
    int []right = new int[n];

    for (int i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.Max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.Max(right[n - i], a[n - 1 - i]);
    }

    for (int i = 0, j = k - 1; j < n; i++, j++)
      Console.Write(Math.Max(left[j], right[i]) + " ");
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int []a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int n = a.Length;
    int K = 3;

    printKMax(a, n, K);

  }
}

// This code is contributed by shivanisinghss2110

Javascript

<script>

// JavaScript program to find the maximum for each
// and every contiguous subarray of size K
// Function to find the maximum for each
// and every contiguous subarray of size k
function printKMax(a, n, k)
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (var i = 0; i < n; i += 1)
        document.write(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    var left = [n];
    var right = [n];

    for (var i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.max(right[n - i], a[n - 1 - i]);
    }

    for (var i = 0, j = k - 1; j < n; i++, j++)
      document.write(Math.max(left[j], right[i]) + " ");
  }

  // Driver Code
    var a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
    var n = a.length;
    var K = 3;

    printKMax(a, n, K);

// This code is contributed by shivanisinghss2110

</script>

Output

3 4 5 6 7 8 9 10 

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