Queries to find maximum sum contiguous subarrays of given length in a rotating array
Last Updated :
04 Jun, 2021
Given an array arr[] of N integers and Q queries of the form {X, Y} of the following two types:
- If X = 1, rotate the given array to the left by Y positions.
- If X = 2, print the maximum sum subarray of length Y in the current state of the array.
Examples:
Input: N = 5, arr[] = {1, 2, 3, 4, 5}, Q = 2, Query[][] = {{1, 2}, {2, 3}}
Output:
Query 1: 3 4 5 1 2
Query 2: 12
Explanation:
Query 1: Shift array to the left 2 times: {1, 2, 3, 4, 5} -> {2, 3, 4, 5, 1} -> {3, 4, 5, 1, 2}
Query 2: Maximum sum subarray of length 3 is {3, 4, 5} and the sum is 12
Input: N = 5, arr[] = {3, 4, 5, 1, 2}, Q = 3, Query[][] = {{1, 3}, {1, 1}, {2, 4}}
Output:
Query 1: 1 2 3 4 5
Query 2: 2 3 4 5 1
Query 3: 14
Explanation:
Query 1: Shift array to the left 3 times: {3, 4, 5, 1, 2} -> {4, 5, 1, 2, 3} -> {5, 1, 2, 3, 4} -> {1, 2, 3, 4, 5}
Query 2: Shift array to the left 1 time: {1, 2, 3, 4, 5} -> {2, 3, 4, 5, 1}
Query 3: Maximum sum subarray of length 4 is {2, 3, 4, 5} and sum is 14
Naive Approach: The simplest approach is to rotate the array by shifting elements one by one up to distance Y for queries is of type 1 and generating the sum of all the subarrays of length Y and print the maximum sum if the query is of type 2.
Time Complexity: O(Q*N*Y)
Auxiliary Space: O(N)
Efficient Approach: To optimize the above approach, the idea is to use the Juggling Algorithm for array rotation and for finding the maximum sum subarray of length Y, use the Sliding Window Technique. Follow the steps below to solve the problem:
- If X = 1, rotate the array by Y, using the Juggling Algorithm.
- Otherwise, if X = 2, find the maximum sum subarray of length Y using the Sliding Window Technique.
- Print the array if query X is 1.
- Otherwise, print the maximum sum subarray of size Y.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int MaxSum(vector< int > arr, int n,
int k)
{
int i, max_sum = 0, sum = 0;
for (i = 0; i < k; i++) {
sum += arr[i];
}
max_sum = sum;
while (i < n) {
sum = sum - arr[i - k] + arr[i];
if (max_sum < sum) {
max_sum = sum;
}
i++;
}
return max_sum;
}
int gcd( int n1, int n2)
{
if (n2 == 0) {
return n1;
}
else {
return gcd(n2, n1 % n2);
}
}
vector< int > RotateArr(vector< int > arr,
int n, int d)
{
int i = 0, j = 0;
d = d % n;
int no_of_sets = gcd(d, n);
for (i = 0; i < no_of_sets; i++) {
int temp = arr[i];
j = i;
while ( true ) {
int k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break ;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
return arr;
}
void performQuery(vector< int >& arr,
int Q[][2], int q)
{
int N = ( int )arr.size();
for ( int i = 0; i < q; i++) {
if (Q[i][0] == 1) {
arr = RotateArr(arr, N,
Q[i][1]);
for ( auto t : arr) {
cout << t << " " ;
}
cout << "\n" ;
}
else {
cout << MaxSum(arr, N, Q[i][1])
<< "\n" ;
}
}
}
int main()
{
vector< int > arr = { 1, 2, 3, 4, 5 };
int q = 5;
int Q[][2] = { { 1, 2 }, { 2, 3 },
{ 1, 3 }, { 1, 1 },
{ 2, 4 }
};
performQuery(arr, Q, q);
return 0;
}
|
Java
class GFG{
static int MaxSum( int []arr,
int n, int k)
{
int i, max_sum = 0 , sum = 0 ;
for (i = 0 ; i < k; i++)
{
sum += arr[i];
}
max_sum = sum;
while (i < n)
{
sum = sum - arr[i - k] +
arr[i];
if (max_sum < sum)
{
max_sum = sum;
}
i++;
}
return max_sum;
}
static int gcd( int n1, int n2)
{
if (n2 == 0 )
{
return n1;
}
else
{
return gcd(n2, n1 % n2);
}
}
static int []RotateArr( int []arr,
int n, int d)
{
int i = 0 , j = 0 ;
d = d % n;
int no_of_sets = gcd(d, n);
for (i = 0 ; i < no_of_sets; i++)
{
int temp = arr[i];
j = i;
while ( true )
{
int k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break ;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
return arr;
}
static void performQuery( int []arr,
int Q[][], int q)
{
int N = arr.length;
for ( int i = 0 ; i < q; i++)
{
if (Q[i][ 0 ] == 1 )
{
arr = RotateArr(arr, N,
Q[i][ 1 ]);
for ( int t : arr)
{
System.out.print(t + " " );
}
System.out.print( "\n" );
}
else
{
System.out.print(MaxSum(arr, N,
Q[i][ 1 ]) + "\n" );
}
}
}
public static void main(String[] args)
{
int []arr = { 1 , 2 , 3 , 4 , 5 };
int q = 5 ;
int Q[][] = {{ 1 , 2 }, { 2 , 3 },
{ 1 , 3 }, { 1 , 1 },
{ 2 , 4 }};
performQuery(arr, Q, q);
}
}
|
Python3
def MaxSum(arr, n, k):
i, max_sum = 0 , 0
sum = 0
while i < k:
sum + = arr[i]
i + = 1
max_sum = sum
while (i < n):
sum = sum - arr[i - k] + arr[i]
if (max_sum < sum ):
max_sum = sum
i + = 1
return max_sum
def gcd(n1, n2):
if (n2 = = 0 ):
return n1
else :
return gcd(n2, n1 % n2)
def RotateArr(arr, n, d):
i = 0
j = 0
d = d % n
no_of_sets = gcd(d, n)
for i in range (no_of_sets):
temp = arr[i]
j = i
while ( True ):
k = j + d
if (k > = n):
k = k - n
if (k = = i):
break
arr[j] = arr[k]
j = k
arr[j] = temp
return arr
def performQuery(arr, Q, q):
N = len (arr)
for i in range (q):
if (Q[i][ 0 ] = = 1 ):
arr = RotateArr(arr, N, Q[i][ 1 ])
for t in arr:
print (t, end = " " )
print ()
else :
print (MaxSum(arr, N, Q[i][ 1 ]))
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 ]
q = 5
Q = [ [ 1 , 2 ], [ 2 , 3 ],
[ 1 , 3 ], [ 1 , 1 ],
[ 2 , 4 ] ]
performQuery(arr, Q, q)
|
C#
using System;
class GFG{
static int MaxSum( int [] arr, int n,
int k)
{
int i, max_sum = 0, sum = 0;
for (i = 0; i < k; i++)
{
sum += arr[i];
}
max_sum = sum;
while (i < n)
{
sum = sum - arr[i - k] +
arr[i];
if (max_sum < sum)
{
max_sum = sum;
}
i++;
}
return max_sum;
}
static int gcd( int n1, int n2)
{
if (n2 == 0)
{
return n1;
}
else
{
return gcd(n2, n1 % n2);
}
}
static int []RotateArr( int []arr, int n,
int d)
{
int i = 0, j = 0;
d = d % n;
int no_of_sets = gcd(d, n);
for (i = 0; i < no_of_sets; i++)
{
int temp = arr[i];
j = i;
while ( true )
{
int k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break ;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
return arr;
}
static void performQuery( int [] arr,
int [,] Q, int q)
{
int N = arr.Length;
for ( int i = 0; i < q; i++)
{
if (Q[i, 0] == 1)
{
arr = RotateArr(arr, N,
Q[i, 1]);
for ( int t = 0; t < arr.Length; t++)
{
Console.Write(arr[t] + " " );
}
Console.WriteLine();
}
else
{
Console.WriteLine(MaxSum(arr, N,
Q[i, 1]));
}
}
}
static void Main()
{
int [] arr = { 1, 2, 3, 4, 5 };
int q = 5;
int [,] Q = { { 1, 2 }, { 2, 3 },
{ 1, 3 }, { 1, 1 },
{ 2, 4 } };
performQuery(arr, Q, q);
}
}
|
Javascript
<script>
function MaxSum(arr , n , k) {
var i, max_sum = 0, sum = 0;
for (i = 0; i < k; i++) {
sum += arr[i];
}
max_sum = sum;
while (i < n) {
sum = sum - arr[i - k] + arr[i];
if (max_sum < sum) {
max_sum = sum;
}
i++;
}
return max_sum;
}
function gcd(n1 , n2) {
if (n2 == 0) {
return n1;
}
else {
return gcd(n2, n1 % n2);
}
}
function RotateArr(arr , n , d) {
var i = 0, j = 0;
d = d % n;
var no_of_sets = gcd(d, n);
for (i = 0; i < no_of_sets; i++) {
var temp = arr[i];
j = i;
while ( true ) {
var k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break ;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
return arr;
}
function performQuery(arr , Q , q) {
var N = arr.length;
for (i = 0; i < q; i++) {
if (Q[i][0] == 1) {
arr = RotateArr(arr, N, Q[i][1]);
for ( var t =0 ;t< arr.length;t++) {
document.write(arr[t] + " " );
}
document.write( "<br/>" );
}
else {
document.write(MaxSum(arr, N, Q[i][1]) + "<br/>" );
}
}
}
var arr = [ 1, 2, 3, 4, 5 ];
var q = 5;
var Q = [ [ 1, 2 ], [ 2, 3 ], [ 1, 3 ], [ 1, 1 ], [ 2, 4 ] ];
performQuery(arr, Q, q);
</script>
|
Output:
3 4 5 1 2
12
1 2 3 4 5
2 3 4 5 1
14
Time Complexity: O(Q*N), where Q is the number of queries, and N is the size of the given array.
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...