Related Articles

# Sliding Window Maximum : Set 2

• Difficulty Level : Medium
• Last Updated : 08 Jun, 2021

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 ``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, prall 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

 ``
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 ``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
Output
`3 4 5 6 7 8 9 10 `

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up