Skip to content
Related Articles

Related Articles

Improve Article

Maximize sum of second minimums of each K length partitions of the array

  • Last Updated : 31 May, 2021

Given an array A[] of size N and a positive integer K ( which will always be a factor of N), the task is to find the maximum possible sum of the second smallest elements of each partition of the array by partitioning the array into (N / K) partitions of equal size.

Examples: 

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.

Input: A[] = {2, 3, 1, 4, 7, 5, 6, 1}, K = 4
Output: 7
Explanation: Split the array as {1, 2, 3, 4} and {1, 5, 6, 7}. Therefore, sum = 2 + 5 = 7, which is the maximum possible sum.



Input: A[] = {12, 43, 15, 32, 45, 23}, K = 3
Output : 66
Explanation: Split the array as {12, 23, 32} and {15, 43, 45}. Therefore, sum = 23 + 43 = 66, which is the maximum possible sum.

Approach: The idea is to sort the given array in ascending order and in order to maximize the required sum, divide the first N / K elements of A[] to each of the arrays as their first term, then choose every (K – 1)th element of A[] starting from N/K

Follow the steps below to solve the problem: 

  • Sort the array A[] in increasing order.
  • Initialize sum with 0 to store the required sum.
  • Now, initialize a variable i with N / K.
  • While i is less than N, perform the following steps:
    • Increment sum by A[i].
    • Increment i by K – 1.
  • After traversing, print sum as the required answer.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum sum of
// second smallest of each partition
// of size K
void findSum(int A[], int N, int K)
{
 
    // Sort the array A[]
    // in ascending order
    sort(A, A + N);
 
    // Store the maximum sum of second
    // smallest of each partition
    // of size K
    int sum = 0;
 
    // Select every (K-1)th element as
    // second smallest element
    for (int i = N / K; i < N; i += K - 1) {
 
        // Update sum
        sum += A[i];
    }
 
    // Print the maximum sum
    cout << sum;
}
 
// Driver Code
int main()
{
 
    // Given size of partitions
    int K = 4;
 
    // Given array A[]
    int A[] = { 2, 3, 1, 4, 7, 5, 6, 1 };
 
    // Size of the given array
    int N = sizeof(A) / sizeof(A[0]);
 
    // Function Call
    findSum(A, N, K);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the maximum sum of
// second smallest of each partition
// of size K
static void findSum(int A[], int N, int K)
{
     
    // Sort the array A[]
    // in ascending order
    Arrays.sort(A);
     
    // Store the maximum sum of second
    // smallest of each partition
    // of size K
    int sum = 0;
 
    // Select every (K-1)th element as
    // second smallest element
    for(int i = N / K; i < N; i += K - 1)
    {
         
        // Update sum
        sum += A[i];
    }
 
    // Print the maximum sum
    System.out.print(sum);
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given size of partitions
    int K = 4;
 
    // Given array A[]
    int A[] = { 2, 3, 1, 4, 7, 5, 6, 1 };
 
    // Size of the given array
    int N = A.length;
 
    // Function Call
    findSum(A, N, K);
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 program for the above approach
 
# Function to find the maximum sum of
# second smallest of each partition
# of size K
def findSum(A, N, K):
   
    # Sort the array A
    # in ascending order
    A.sort();
 
    # Store the maximum sum of second
    # smallest of each partition
    # of size K
    sum = 0;
 
    # Select every (K-1)th element as
    # second smallest element
    for i in range(N // K, N, K - 1):
       
        # Update sum
        sum += A[i];
 
    # Print the maximum sum
    print(sum);
 
# Driver Code
if __name__ == '__main__':
   
    # Given size of partitions
    K = 4;
 
    # Given array A
    A = [2, 3, 1, 4, 7, 5, 6, 1];
 
    # Size of the given array
    N = len(A);
 
    # Function Call
    findSum(A, N, K);
 
    # This code contributed by shikhasingrajput

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the maximum sum of
// second smallest of each partition
// of size K
static void findSum(int []A, int N, int K)
{
     
    // Sort the array []A
    // in ascending order
    Array.Sort(A);
     
    // Store the maximum sum of second
    // smallest of each partition
    // of size K
    int sum = 0;
 
    // Select every (K-1)th element as
    // second smallest element
    for(int i = N / K; i < N; i += K - 1)
    {
         
        // Update sum
        sum += A[i];
    }
     
    // Print the maximum sum
    Console.Write(sum);
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given size of partitions
    int K = 4;
 
    // Given array []A
    int []A = { 2, 3, 1, 4, 7, 5, 6, 1 };
 
    // Size of the given array
    int N = A.Length;
 
    // Function Call
    findSum(A, N, K);
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
 
// Javascript program of the above approach
 
// Function to find the maximum sum of
// second smallest of each partition
// of size K
function findSum(A, N, K)
{
     
    // Sort the array A[]
    // in ascending order
    A.sort();
      
    // Store the maximum sum of second
    // smallest of each partition
    // of size K
    let sum = 0;
  
    // Select every (K-1)th element as
    // second smallest element
    for(let i = N / K; i < N; i += K - 1)
    {
         
        // Update sum
        sum += A[i];
    }
  
    // Print the maximum sum
    document.write(sum);
}
 
// Driver Code
 
// Given size of partitions
let K = 4;
 
// Given array A[]
let A = [ 2, 3, 1, 4, 7, 5, 6, 1 ];
 
// Size of the given array
let N = A.length;
 
// Function Call
findSum(A, N, K);
 
// This code is contributed by chinmoy1997pal
 
</script>
Output: 
7

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :