Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum sum subsequence with values differing by at least 2

  • Difficulty Level : Hard
  • Last Updated : 27 May, 2021

Given a positive integer array arr[] of size N, the task is to find the maximum sum of a subsequence with the constraint that no 2 numbers in the sequence should be adjacent to the value i.e. if arr[i] is taken into the answer, then neither occurrences of arr[i]-1 nor arr[i]+1 can be selected.

Examples: 

Input: arr[] = {2, 2, 2} 
Output: 6 
Explanation: 
The max sum subsequence will be [2, 2, 2] as it does not contain any occurrence of 1 or 3. Hence sum = 2 + 2 + 2 = 6

Input: arr[] = {2, 2, 3} 
Output: 4
Explanation: 
Subsequence 1: [2, 2] as it does not contain any occurrence of 1 or 3. Hence sum = 2 + 2 = 4 
Subsequence 2: [3] as it does not contain any occurrence of 2 or 4. Hence sum = 3 
Therefore, the max sum = 4

Solution Approach: The idea is to use Dynamic Programming, similar to this article. 

  1. Create a map to store the number of times the element i appears in the sequence.
  2. To find the answer, it would be easy to first break the problem down into smaller problems. In this case, break the sequence into smaller sequences and find an optimal solution for it.
  3. For the sequence of numbers containing only 0, the answer would be 0. Similarly, if a sequence contains only the numbers 0 and 1, then the solution would be to count[1]*1.
  4. Now build a recursive solution to this problem. For a sequence of numbers containing only the numbers, 0 to n, the choice is to either pick the Nth element or not.

dp[i] = max(dp[i – 1], dp[i – 2] + i*freq[i] ) 
dp[i-1] represents not picking the ith number, then the number before it can be considered.
dp[i – 2] + i*freq[i] represents picking the ith number, then the number before it is eliminated. Hence, the number before that is considered. 

C++




// C++ program to find maximum sum
// subsequence with values
// differing by at least 2
 
#include <bits/stdc++.h>
using namespace std;
 
// function to find maximum sum
// subsequence such that two
// adjacent values elements are
// not selected
int get_max_sum(int arr[], int n)
{
    // map to store the frequency
    // of array elements
    unordered_map<int, int> freq;
 
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
 
    // make a dp array to store
    // answer upto i th value
    int dp[100001];
    memset(dp, 0, sizeof(dp));
 
    // base cases
    dp[0] = 0;
    dp[1] = freq[0];
 
    // iterate for all possible
    // values  of arr[i]
    for (int i = 2; i <= 100000; i++) {
        dp[i] = max(dp[i - 1],
                    dp[i - 2] + i * freq[i]);
    }
 
    // return the last value
    return dp[100000];
}
 
// Driver function
int main()
{
 
    int N = 3;
    int arr[] = { 2, 2, 3 };
    cout << get_max_sum(arr, N);
    return 0;
}
Java



// Java program to find maximum sum
// subsequence with values
// differing by at least 2
import java.util.*;
import java.lang.*;
 
class GFG{
 
// Function to find maximum sum
// subsequence such that two
// adjacent values elements are
// not selected
public static int get_max_sum(int arr[], int n)
{
     
    // map to store the frequency
    // of array elements
    HashMap<Integer,
            Integer> freq = new HashMap<Integer,
                                        Integer>();
 
    for(int i = 0; i < n; i++)
    {
        if (freq.containsKey(arr[i]))
        {
            int x = freq.get(arr[i]);
            freq.replace(arr[i], x + 1);
        }
        else
            freq.put(arr[i], 1);
    }
 
    // Make a dp array to store
    // answer upto i th value
    int[] dp = new int[100001];
    for(int i = 0; i < 100001; i++)
        dp[i] = 0;
 
    // Base cases
    dp[0] = 0;
    if (freq.containsKey(0))
        dp[1] = freq.get(0);
    else
        dp[1] = 0;
 
    // Iterate for all possible
    // values of arr[i]
    for(int i = 2; i <= 100000; i++)
    {
        int temp = (freq.containsKey(i)) ?
                    freq.get(i) : 0;
        dp[i] = Math.max(dp[i - 1],
                         dp[i - 2] + i * temp);
    }
 
    // Return the last value
    return dp[100000];
}
 
// Driver code
public static void main(String[] args)
{
    int N = 3;
    int arr[] = { 2, 2, 3 };
     
    System.out.println(get_max_sum(arr, N));
}
}
 
// This code is contributed by grand_master
Python3



# Python3 program to find maximum sum
# subsequence with values
# differing by at least 2
from collections import defaultdict
 
# Function to find maximum sum
# subsequence such that two
# adjacent values elements are
# not selected
def get_max_sum(arr, n):
     
    # Map to store the frequency
    # of array elements
    freq = defaultdict(lambda : 0)
     
    for i in range(n):
        freq[arr[i]] += 1
     
    # Make a dp array to store
    # answer upto i th value
    dp = [0] * 100001
     
    # Base cases
    dp[0] = 0
    dp[1] = freq[0]
     
    # Iterate for all possible
    # values of arr[i]
    for i in range(2, 100000 + 1):
        dp[i] = max(dp[i - 1],
                    dp[i - 2] + i * freq[i])
         
    # Return the last value
    return dp[100000]
 
# Driver code
N = 3
arr = [ 2, 2, 3 ]
     
print(get_max_sum(arr, N))
 
# This code is contributed by stutipathak31jan
C#



// C# program to find maximum sum
// subsequence with values
// differing by at least 2
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find maximum sum
// subsequence such that two
// adjacent values elements are
// not selected
public static int get_max_sum(int []arr, int n)
{
     
    // map to store the frequency
    // of array elements
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();
 
    for(int i = 0; i < n; i++)
    {
        if (freq.ContainsKey(arr[i]))
        {
            int x = freq[arr[i]];
            freq[arr[i]]= x + 1;
        }
        else
            freq.Add(arr[i], 1);
    }
 
    // Make a dp array to store
    // answer upto i th value
    int[] dp = new int[100001];
    for(int i = 0; i < 100001; i++)
        dp[i] = 0;
 
    // Base cases
    dp[0] = 0;
    if (freq.ContainsKey(0))
        dp[1] = freq[0];
    else
        dp[1] = 0;
 
    // Iterate for all possible
    // values of arr[i]
    for(int i = 2; i <= 100000; i++)
    {
        int temp = (freq.ContainsKey(i)) ?
                    freq[i] : 0;
        dp[i] = Math.Max(dp[i - 1],
                         dp[i - 2] + i * temp);
    }
 
    // Return the last value
    return dp[100000];
}
 
// Driver code
public static void Main(String[] args)
{
    int N = 3;
    int []arr = { 2, 2, 3 };
     
    Console.WriteLine(get_max_sum(arr, N));
}
}
 
// This code is contributed by Amit Katiyar
Javascript



<script>
 
 
// Javascript program to find maximum sum
// subsequence with values
// differing by at least 2
 
// function to find maximum sum
// subsequence such that two
// adjacent values elements are
// not selected
function get_max_sum(arr, n)
{
    // map to store the frequency
    // of array elements
    var freq = new Map();
 
    for (var i = 0; i < n; i++) {
        if(freq.has(arr[i]))
            freq.set(arr[i], freq.get(arr[i])+1)
        else
            freq.set(arr[i], 1)
    }
 
    // make a dp array to store
    // answer upto i th value
    var dp = Array(100001).fill(0);
 
    // base cases
    dp[0] = 0;
    dp[1] = (freq.has(0)?freq.get(0):0);
 
    // iterate for all possible
    // values  of arr[i]
    for (var i = 2; i <= 100000; i++) {
        dp[i] = Math.max(dp[i - 1],
                    dp[i - 2] + i * (freq.has(i)?freq.get(i):0));
    }
 
    // return the last value
    return dp[100000];
}
 
// Driver function
var N = 3;
var arr = [2, 2, 3];
document.write( get_max_sum(arr, N));
 
</script>
Output: 
4
 
Time Complexity: O(N) 
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Previous
Longest subarray such that difference of max and min is at-most K
Next

Different Ways to Take Input and Print a Float Value in C#
Recommended Articles
Page :
Longest Subsequence with absolute difference of pairs as at least Subsequence's maximum
24, Feb 22
Count Subarrays with Consecutive elements differing by 1
30, Dec 18
Find index of the element differing in parity with all other array elements
31, Jan 21
Maximum sum subsequence with at-least k distant elements
31, Oct 17
Count of index subsets such that maximum of values over these indices in A is at least total sum over B
20, Sep 21
Maximum sum of a subsequence having difference between their indices equal to the difference between their values
17, Jun 21
Minimum days to make Array elements with value at least K sum at least X
07, Jul 21
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Count maximum occurrence of subsequence in string such that indices in subsequence is in A.P.
09, Apr 20
Minimum sum subsequence such that at least one of every four consecutive elements is picked
02, Jan 17
Maximum length Subsequence with alternating sign and maximum Sum
22, Apr 20
First subarray having sum at least half the maximum sum of any subarray of size K
09, Sep 20
Count pairs (p, q) such that p occurs in array at least q times and q occurs at least p times
25, Feb 19
Lexicographically largest subsequence such that every character occurs at least k times
14, Oct 17
Longest subsequence where each character occurs at least k times
29, Jan 18
Longest Subsequence with at least one common digit in every element
26, Oct 18
Longest subsequence such that adjacent elements have at least one common digit
25, Feb 19
Longest subsequence with at least one character appearing in every string
18, Jul 19
Check if an array has some palindromic subsequence of length at least 3
27, Apr 20
Split array into maximum possible subsets having product of their length with the maximum element at least K
30, Jul 21
Minimize count of array elements to be removed such that at least K elements are equal to their index values
20, Sep 21
Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
12, Jul 19
Longest Increasing Subsequence using Longest Common Subsequence Algorithm
14, Oct 19
Find the equal pairs of subsequence of S and subsequence of T
22, Nov 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
yash2040
@yash2040
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!