Friday, November 29, 2024
Google search engine
HomeData Modelling & AISubsequence with maximum odd sum

Subsequence with maximum odd sum

Given a set of integers, check whether there is a subsequence with odd sum and if yes, then finding the maximum odd sum. If no subsequence contains odd sum, return -1.

Examples : 

Input : arr[] = {2, 5, -4, 3, -1};
Output : 9
The subsequence with maximum odd 
sum is 2, 5, 3 and -1.

Input : arr[] = {4, -3, 3, -5}
Output : 7
The subsequence with maximum odd
sum is 4 and 3

Input :  arr[] = {2, 4, 6}
Output : -1
There is no subsequence with odd sum.
Recommended Practice

A simple solution to generate all subsequences and find the maximum sum of all subsequences with odd sums. Time complexity of this solution would be exponential.

An efficient solution can work in O(n) time. The idea is based on the following facts. 

  1. Odd sum is not possible if all numbers are even. Otherwise, we always find an answer. 
  2. If odd sum is possible, we find sum of all positive integers. If sum is odd, we return it as this is the maximum overall positive sum. If sum is even, we subtract the odd number with the smallest absolute value from sum. This step can be justified by the fact that the smallest absolute odd value number becomes part of result if it is negative, and removed from the result when it is positive.

Implementation:

C++




// C++ program to find maximum sum of odd
// subsequence if it exists.
#include<bits/stdc++.h>
using namespace std;
 
// Returns maximum sum odd subsequence if exists
// Else returns -1
int findMaxOddSubarraySum(int arr[], int n)
{
    // Here min_odd is the minimum odd number (in
    // absolute terms). Initializing with max value
    // of int .
    int min_odd = INT_MAX;
 
    // To check if there is al-least one odd number.
    bool isOdd = false;
 
    int sum = 0;  // To store sum of all positive elements
    for (int i=0 ; i<n ; i++)
    {
        // Adding positive number would increase
        // the sum.
        if (arr[i] > 0)
            sum = sum + arr[i];
 
        // To find the minimum odd number(absolute)
        // in the array.
        if (arr[i]%2 != 0)
        {
            isOdd = true;
            if (min_odd> abs(arr[i]))
                min_odd = abs(arr[i]);
        }
    }
 
    // If there was no odd number
    if (isOdd == false)
       return -1;
 
    // Now, sum will be either odd or even.
    // If even, changing it to odd. As, even - odd = odd.
    // since m is the minimum odd number(absolute).
    if (sum%2 == 0)
        sum = sum - min_odd;
 
    return sum;
}
 
// Driver code
int main()
{
    int arr[] = {2, -3, 5, -1, 4};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << findMaxOddSubarraySum(arr, n);
    return 0;
}


Java




// Java program to find maximum sum
// of odd subsequence if it exists.
import java.io.*;
 
class GFG {
     
// Returns maximum sum odd subsequence,
// if exists Else returns -1
static int findMaxOddSubarraySum(int arr[], int n)
{
    // Here min_odd is the minimum odd number
    // (in absolute terms). Initializing with
    // max value of int .
    int min_odd = Integer.MAX_VALUE;
 
    // To check if there is al-least
    // one odd number.
    boolean isOdd = false;
     
    // To store sum of all positive elements
    int sum = 0;
    for (int i = 0 ; i < n ; i++)
    {
        // Adding positive number would
        // increase the sum.
        if (arr[i] > 0)
            sum = sum + arr[i];
 
        // To find the minimum odd number
        // (absolute) in the array.
        if (arr[i] % 2 != 0)
        {
            isOdd = true;
            if (min_odd > Math.abs(arr[i]))
                min_odd = Math.abs(arr[i]);
        }
    }
 
    // If there was no odd number
    if (isOdd == false)
    return -1;
 
    // Now, sum will be either odd or even.
    // If even, changing it to odd.
    // As, even - odd = odd.
    // since m is the minimum odd
    // number(absolute).
    if (sum % 2 == 0)
        sum = sum - min_odd;
 
    return sum;
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = {2, -3, 5, -1, 4};
    int n = arr.length;
    System.out.println(findMaxOddSubarraySum(arr, n));
         
}
}
 
// This code is contributed by vt_m


Python3




# Python program to find
# maximum sum of odd
# subsequence if it exists.
 
# Returns maximum sum odd
# subsequence if exists
# Else returns -1
def findMaxOddSubarraySum(arr, n):
 
    # Here min_odd is the
    # minimum odd number (in
    # absolute terms).
    # Initializing with max value
    # of int .
    min_odd = +2147483647
  
    # To check if there is
    # at-least one odd number.
    isOdd = False
     
    # To store sum of
    # all positive elements
    sum = 0 
    for i in range(n):
     
        # Adding positive number
        # would increase
        # the sum.
        if (arr[i] > 0):
            sum = sum + arr[i]
  
        # To find the minimum
        # odd number(absolute)
        # in the array.
        if (arr[i]%2 != 0):
         
            isOdd = True
            if (min_odd > abs(arr[i])):
                min_odd = abs(arr[i])
  
    # If there was no odd number
    if (isOdd == False):
         return -1
  
    # Now, sum will be
    # either odd or even.
    # If even, changing it to
    # odd. As, even - odd = odd.
    # since m is the minimum
    # odd number(absolute).
    if (sum%2 == 0):
        sum = sum - min_odd
  
    return sum
 
  
# Driver code
 
arr = [2, -3, 5, -1, 4]
n =len(arr)
 
print(findMaxOddSubarraySum(arr, n))
 
# This code is contributed
# by Anant Agarwal.


C#




// C# program to find maximum sum
// of odd subsequence if it exists.
using System;
 
class GFG {
     
    // Returns maximum sum odd subsequence,
    // if exists Else returns -1
    static int findMaxOddSubarraySum(int []arr, int n)
    {
         
        // Here min_odd is the minimum odd number
        // (in absolute terms). Initializing with
        // max value of int .
        int min_odd = int.MaxValue;
     
        // To check if there is al-least
        // one odd number.
        bool isOdd = false;
         
        // To store sum of all positive elements
        int sum = 0;
        for (int i = 0 ; i < n ; i++)
        {
             
            // Adding positive number would
            // increase the sum.
            if (arr[i] > 0)
                sum = sum + arr[i];
     
            // To find the minimum odd number
            // (absolute) in the array.
            if (arr[i] % 2 != 0)
            {
                isOdd = true;
                if (min_odd > Math.Abs(arr[i]))
                    min_odd = Math.Abs(arr[i]);
            }
        }
     
        // If there was no odd number
        if (isOdd == false)
            return -1;
     
        // Now, sum will be either odd or even.
        // If even, changing it to odd.
        // As, even - odd = odd.
        // since m is the minimum odd
        // number(absolute).
        if (sum % 2 == 0)
            sum = sum - min_odd;
     
        return sum;
    }
     
    // Driver code
    public static void Main ()
    {
        int []arr = {2, -3, 5, -1, 4};
        int n = arr.Length;
        Console.Write(findMaxOddSubarraySum(arr, n));
             
    }
}
 
// This code is contributed by nitin mittal.


PHP




<?php
// PHP program to find maximum
// sum of odd subsequence if
// it exists.
 
// Returns maximum sum odd
// subsequence if exists Else
// returns -1
function findMaxOddSubarraySum( $arr, $n)
{
    // Here min_odd is the minimum
    // odd number (in absolute terms).
    // Initializing with max value
    // of int .
    $min_odd = PHP_INT_MAX;
 
    // To check if there is
    // at-least one odd number.
    $isOdd = false;
 
    // To store sum of all
    // positive elements
    $sum = 0;
    for ( $i = 0; $i < $n; $i++)
    {
        // Adding positive number
        // would increase the sum.
        if ($arr[$i] > 0)
            $sum = $sum + $arr[$i];
 
        // To find the minimum odd
        // number(absolute) in the array.
        if ($arr[$i] % 2 != 0)
        {
            $isOdd = true;
            if ($min_odd > abs($arr[$i]))
                $min_odd = abs($arr[$i]);
        }
    }
 
    // If there was no odd number
    if ($isOdd == false)
    return -1;
 
    // Now, sum will be either
    // odd or even. If even,
    // changing it to odd. As,
    // even - odd = odd. since
    // m is the minimum odd
    // number(absolute).
    if ($sum % 2 == 0)
        $sum = $sum - $min_odd;
 
    return $sum;
}
 
// Driver code
$arr = array(2, -3, 5, -1, 4);
$n = count($arr);
echo findMaxOddSubarraySum($arr, $n);
 
// This code is contributed by anuj_67.
?>


Javascript




<script>
    // Javascript program to find maximum sum
    // of odd subsequence if it exists.
     
    // Returns maximum sum odd subsequence,
    // if exists Else returns -1
    function findMaxOddSubarraySum(arr, n)
    {
           
        // Here min_odd is the minimum odd number
        // (in absolute terms). Initializing with
        // max value of int .
        let min_odd = Number.MAX_VALUE;
       
        // To check if there is al-least
        // one odd number.
        let isOdd = false;
           
        // To store sum of all positive elements
        let sum = 0;
        for (let i = 0 ; i < n ; i++)
        {
               
            // Adding positive number would
            // increase the sum.
            if (arr[i] > 0)
                sum = sum + arr[i];
       
            // To find the minimum odd number
            // (absolute) in the array.
            if (arr[i] % 2 != 0)
            {
                isOdd = true;
                if (min_odd > Math.abs(arr[i]))
                    min_odd = Math.abs(arr[i]);
            }
        }
       
        // If there was no odd number
        if (isOdd == false)
            return -1;
       
        // Now, sum will be either odd or even.
        // If even, changing it to odd.
        // As, even - odd = odd.
        // since m is the minimum odd
        // number(absolute).
        if (sum % 2 == 0)
            sum = sum - min_odd;
       
        return sum;
    }
     
    let arr = [2, -3, 5, -1, 4];
    let n = arr.length;
    document.write(findMaxOddSubarraySum(arr, n));
  
 // This code is contributed by rameshtravel07.
</script>


Output

11

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

This article is contributed by Jatin Goyal. If you like neveropen and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the neveropen main page and help other Geeks. 

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

Dominic Rubhabha-Wardslaus
Dominic Rubhabha-Wardslaushttp://wardslaus.com
infosec,malicious & dos attacks generator, boot rom exploit philanthropist , wild hacker , game developer,
RELATED ARTICLES

Most Popular

Recent Comments