Inverse Coin Change

Inverse Coin Change - Problem

You are given a 1-indexed integer array numWays, where numWays[i] represents the number of ways to select a total amount i using an infinite supply of some fixed coin denominations.

Each denomination is a positive integer with value at most numWays.length. However, the exact coin denominations have been lost.

Your task is to recover the set of denominations that could have resulted in the given numWays array.

Return a sorted array containing unique integers which represents this set of denominations. If no such set exists, return an empty array.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: With coins [1,2]: ways to make 1=1 (coin 1), ways to make 2=1 (coin 2), ways to make 3=2 (1+1+1 or 1+2), ways to make 4=2 (1+1+1+1 or 2+2), ways to make 5=3 (add coin 1 or 2 to make 4 or 3), ways to make 6=4 (multiple combinations)

Example 2 — Single Coin

$ Input: numWays = [1,0,0,1]

› Output: [1,4]

💡 Note: With coins [1,4]: ways to make 1=1 (coin 1), ways to make 2=0 (impossible), ways to make 3=0 (impossible), ways to make 4=1 (coin 4)

Example 3 — No Valid Set

$ Input: numWays = [1,2,3]

› Output: []

💡 Note: No valid coin set can produce this pattern - the growth is too rapid for any reasonable denomination set

Constraints

1 ≤ numWays.length ≤ 1000
0 ≤ numWays[i] ≤ 1000
Each denomination value is at most numWays.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to analyze the numWays pattern to identify which denominations must exist. Best approach uses DP pattern analysis to check if each position requires a new denomination. Time: O(n²), Space: O(n)

Common Approaches

✓ Dfs

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

Brute Force - Try All Combinations

⏱️ Time: O(2^n × n²) Space: O(n²)

Try every possible subset of denominations from 1 to n, then simulate coin change for each subset to see if it produces the given numWays array.

Dynamic Programming - Pattern Analysis

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

Use dynamic programming insights to determine which denominations must exist by analyzing the difference patterns and growth rates in the numWays array.

Optimized - Greedy Reconstruction

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

Instead of trying all combinations, analyze the numWays array to identify which denominations must exist based on the pattern of values.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

void inorder(struct TreeNode* node, int k, int* count, int* result) {
    if (!node || *count >= k) return;
    
    inorder(node->left, k, count, result);
    
    (*count)++;
    if (*count == k) {
        *result = node->val;
        return;
    }
    
    inorder(node->right, k, count, result);
}

int solution(struct TreeNode* root, int k) {
    int count = 0;
    int result = 0;
    inorder(root, k, &count, &result);
    return result;
}

struct TreeNode* newNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    struct TreeNode* root = newNode(3);
    root->left = newNode(1);
    root->right = newNode(4);
    root->left->right = newNode(2);
    
    int k = 1;
    printf("%d\n", solution(root, k));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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