Greatest Sum Divisible by Three

Greatest Sum Divisible by Three - Problem

Given an integer array nums, return the maximum possible sum of elements of the array such that it is divisible by three.

You can select any subset of elements from the array. The sum of the selected elements must be divisible by 3 to be valid.

Note: An empty subset has sum 0, which is divisible by 3.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,6,5,1,8]

› Output: 18

💡 Note: Select [3,6,1,8] with sum=18. Since 18%3=0, this is valid. This is the maximum possible sum divisible by 3.

Example 2 — All Divisible

$ Input: nums = [4]

› Output: 0

💡 Note: 4%3=1, so we cannot include 4. The only valid subset is empty set with sum=0.

Example 3 — Multiple Valid Combinations

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

› Output: 18

💡 Note: Select [3,4,5,6] with sum=18. Alternative: [1,2,3,6] also gives sum=12, but 18 is larger.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Facebook 6

The key insight is to use dynamic programming to track the maximum achievable sum for each remainder (0, 1, 2) when divided by 3. Best approach uses DP with Time: O(n), Space: O(1).

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsets

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

Generate all 2^n possible subsets of the array, calculate the sum of each subset, check if it's divisible by 3, and keep track of the maximum valid sum.

Dynamic Programming

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

Use dynamic programming to maintain the maximum achievable sum for each remainder when divided by 3. For each number, update all three states optimally.

Greedy Approach

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

Group numbers by their remainder when divided by 3. Use greedy strategy to pick combinations that result in sum divisible by 3, prioritizing larger numbers.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void inorder(struct TreeNode* node, struct TreeNode** prev) {
    if (!node) return;
    
    // Process left subtree first
    inorder(node->left, prev);
    
    // Process current node
    node->left = NULL;     // Clear left pointer
    (*prev)->right = node; // Connect previous to current
    *prev = node;          // Update previous to current
    
    // Process right subtree
    inorder(node->right, prev);
}

struct TreeNode* increasingBST(struct TreeNode* root) {
    // Dummy node to simplify edge case handling
    struct TreeNode* dummy = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    dummy->val = 0;
    dummy->left = NULL;
    dummy->right = NULL;
    
    struct TreeNode* prev = dummy;
    inorder(root, &prev);
    
    return dummy->right;
}

// Dummy main to satisfy linker
int main() { return 0; }

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

52.0K Views

Medium Frequency

~25 min Avg. Time

1.2K 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