Longest Harmonious Subsequence

Longest Harmonious Subsequence - Problem

We define a harmonious array as an array where the difference between its maximum value and its minimum value is exactly 1.

Given an integer array nums, return the length of its longest harmonious subsequence among all its possible subsequences.

Note: A subsequence is derived from an array by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Harmonious Array

$ Input: nums = [1,3,2,2,5,2,3,7]

› Output: 5

💡 Note: The longest harmonious subsequence is [3,2,2,2,3] with length 5. It contains numbers 2 and 3, and 3-2=1.

Example 2 — No Harmonious Subsequence

$ Input: nums = [1,2,3,4]

› Output: 2

💡 Note: Multiple harmonious subsequences exist: [1,2], [2,3], [3,4], each with length 2. Return the maximum length which is 2.

Example 3 — All Same Numbers

$ Input: nums = [1,1,1,1]

› Output: 0

💡 Note: All numbers are the same, so max-min=0, not 1. No harmonious subsequence exists.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 8

The key insight is that only consecutive numbers (x and x+1) can form a harmonious subsequence. The optimal approach uses a frequency count hash map to count each number's occurrences, then checks each number x with x+1 to find the maximum combined frequency. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible subsequences and check if each one is harmonious (max - min = 1). Keep track of the longest valid subsequence found.

Frequency Count with Hash Map

⏱️ Time: O(n) Space: O(n)

Count frequency of each number using a hash map. For each number x, if x+1 exists, calculate the harmonious subsequence length as freq[x] + freq[x+1].

Sort First Approach

⏱️ Time: O(n log n) Space: O(1)

Sort the array first, then use a sliding window approach to find the longest segment where the difference between maximum and minimum is exactly 1.

Brute Force — Algorithm Steps

Generate all possible subsequences
For each subsequence, find min and max values
Check if max - min equals 1
Keep track of maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Use bit masks to create all combinations

Check Harmonious

For each subsequence, verify max - min = 1

Track Maximum

Keep the longest harmonious length found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsequence[20];
        int subLen = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            }
        }
        
        if (subLen >= 2) {
            int minVal = INT_MAX, maxVal = INT_MIN;
            for (int i = 0; i < subLen; i++) {
                if (subsequence[i] < minVal) minVal = subsequence[i];
                if (subsequence[i] > maxVal) maxVal = subsequence[i];
            }
            if (maxVal - minVal == 1) {
                if (subLen > maxLength) {
                    maxLength = subLen;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Generate 2^n subsequences and check each one

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth for generating subsequences

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler