Minimize sum of max sized Subsequence such that no two elements are adjacent

Given an array arr[] of positive numbers, the task is to find the minimum sum of a subsequence of maximum possible elements with the constraint that no two numbers in the sequence are adjacent.

Examples:

Input: arr[]={1, 7, 3, 2}
Output: 3
Explanation: Pick the subsequence {1, 2}. 
The sum is 3 and no two elements are adjacent. 
This is the least possible sum.

Input: arr[]={1, 8, 4, 10, 6}
Output: 11
Explanation: Pick the subsequence {1, 4, 6}. 
The sum is 11 and no two elements are adjacent. 
This is the least possible sum.

Input: arr[]={2, 0, 11, 2, 0, 2}
Output: 4
Explanation: Pick the subsequence {0, 2, 2}. 
The sum is 4 and no two elements are adjacent. 
This is the least possible sum.

Approach: To solve the problem follow the below observations:

There are two different cases:

• Array size is Odd – the only choice is to pick the even indexed elements(Zero – Based Indexing). 
• Array size is Even – The subsequence size will be N/2. It can be in three possible ways
  • All the even indexed elements.
  • All the odd indexed elements.
  • Even indexed elements till i and odd indexed elements starting from i+3
  • The minimum among these 3 will be the answer.

Follow the steps to solve the problem:

• If the size of arr[] is Odd, the sum of all the even indexed elements is the answer.
• For Size of arr to Even, store the sum of all the even indices into a variable.
  • Iterating from the end by adding the odd index elements and removing the even indexed elements from the end.
  • Update the minimum answer in each index.
• After the iteration is over, return the minimum value as the answer.

 Below is the implementation of the above approach.

C++

// C++ code for the above approach:

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

// Function to find the minimum sum
int FindMinSum(vector<int>& vec, int n)
{
    int sum = 0;
    for (int i = 0; i < n; i += 2) {

        // Sum of all the even indices
        sum += vec[i];
    }
    if (n % 2 != 0)
        return sum;
    int ans = sum;
    for (int i = n - 1; i > 0; i -= 2) {

        // Removing the even index and
        // addinig the odd index
        sum = sum - vec[i - 1] + vec[i];

        // Checking for the minimum sum
        ans = min(sum, ans);
    }

    // Return the minimum sum
    return ans;
}

// Driver Code
int main()
{

    // Creating the array
    vector<int> arr = { 2, 0, 11, 2, 0, 2 };
    int N = vec.size();

    // Function call
    cout << FindMinSum(arr, N) << endl;

    return 0;
}

C

#include <stdio.h>

int FindMinSum(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i += 2) {
        // sum of all the odd indexes
        sum += arr[i];
    }
    if (n % 2 == 1)
        return sum;
    int ans = sum;
    for (int i = n - 1; i > 0; i -= 2) {
        // removing the odd index and addinig the even index
        sum = sum - arr[i - 1] + arr[i];
        // checking for the minimum sum
        if (sum < ans)
            ans = sum;
    }

    // Return the minimum sum
    return ans;
}
// Driver Code
int main()
{
    // Creating the array
    int arr[] = { 2, 0, 11, 2, 0, 2 };
    int n = *(&arr + 1) - arr;

    // Function call
    int answer = FindMinSum(arr, n);
    printf("%d", answer);

    return 0;
}

Java

import java.io.*;
import java.util.*;

public class GFG {

    static int solve(int vec[], int n)
    {
        int sum = 0;
        if (n % 2 != 0) {
            for (int i = 0; i < n; i = i + 2) {
                // sum of all the odd indexes
                sum = sum + vec[i];
            }
            return sum;
        }
        else {
            int ans = sum;
            for (int i = n - 1; i > 0; i -= 2) {
                // removing the odd index and addinig the
                // even index
                ans = ans - vec[i - 1] + vec[i];
                // checking for the minimum sum
                ans = Math.min(ans, sum);
            }
            // Return the minimum sum
            return ans;
        }
    }
    public static void main(String args[])
        throws IOException
    {
        // Creating the array
        int vec[] = { 2, 1, 2 };

        int n = vec.length;

        // Function call
        System.out.println(solve(vec, n));
    }
}

Python

# Python code to implement the approach
def FindMinSum(list, n):
    sum = 0
    for i in range(0, n, 2):
        # sum of all the odd indexes
        sum = sum + list[i]
    if n % 2 == 1:
        return sum
    ans = sum
    for i in range(n-1, 0, -2):
        # removing the odd index and addinig the even index
        sum = sum - list[i-1] + list[i]
        # checking for the minimum sum
        ans = min(sum, ans)
     # Return the minimum sum
    return ans


# Driver Code
# Creating the list
list = [2, 0, 11, 2, 0, 2]
n = 6
# Function call
k = FindMinSum(list, n)
print(k)

C#

// C# code for the above approach:
using System;

public class GFG {
  static int solve(int[] vec, int n)
  {
    int sum = 0;
    if (n % 2 != 0) {
      for (int i = 0; i < n; i = i + 2)
      {

        // sum of all the odd indexes
        sum = sum + vec[i];
      }
      return sum;
    }
    else {
      int ans = sum;
      for (int i = n - 1; i > 0; i -= 2)
      {

        // removing the odd index and addinig the
        // even index
        ans = ans - vec[i - 1] + vec[i];

        // checking for the minimum sum
        ans = Math.Min(ans, sum);
      }

      // Return the minimum sum
      return ans;
    }
  }

  // Driver Code
  static public void Main()
  {
    // Creating the array
    int[] vec = { 2, 1, 2 };

    int n = vec.Length;

    // Function call
    Console.WriteLine(solve(vec, n));
  }
}

// This code is contributed by Rohit Pradhan

Javascript

<script>
    // JavaScript code for the above approach:

    // Function to find the minimum sum
    const FindMinSum = (vec, n) => {
        let sum = 0;
        for (let i = 0; i < n; i += 2) {

            // Sum of all the even indices
            sum += vec[i];
        }
        if (n % 2 != 0)
            return sum;
        let ans = sum;
        for (let i = n - 1; i > 0; i -= 2) {

            // Removing the even index and
            // addinig the odd index
            sum = sum - vec[i - 1] + vec[i];

            // Checking for the minimum sum
            ans = Math.min(sum, ans);
        }

        // Return the minimum sum
        return ans;
    }

    // Driver Code

    // Creating the array
    let arr = [2, 0, 11, 2, 0, 2];
    let N = arr.length;

    // Function call
    document.write(FindMinSum(arr, N));

// This code is contributed by rakeshsahni

</script>

Output

4

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