Find All Possible Recipes from Given Supplies

Find All Possible Recipes from Given Supplies - Problem

Array Hash Table String Graph Topological Sort Medium

Imagine you're a master chef with a cookbook of recipes and a pantry full of supplies. Your challenge is to determine which recipes you can actually cook!

You have n different recipes, where each recipe has a name and requires specific ingredients. Here's the twist: some recipes can serve as ingredients for other recipes. For example, you might need "dough" to make "pizza", but "dough" itself is another recipe in your cookbook.

Given:

recipes[] - Array of recipe names
ingredients[][] - 2D array where ingredients[i] contains all ingredients needed for recipes[i]
supplies[] - Array of ingredients you initially have (infinite supply)

Goal: Return a list of all recipes you can make, considering that recipes can depend on other recipes. The order doesn't matter.

Note: Two recipes may contain each other in their ingredients (circular dependencies), but you should only return recipes that can actually be completed.

Input & Output

basic_recipes.py — Python

$ Input: recipes = ["bread"], ingredients = [["yeast","flour"]], supplies = ["yeast","flour"]

› Output: ["bread"]

💡 Note: We have yeast and flour, which are exactly the ingredients needed to make bread. Since we can make bread, it's included in the result.

recipe_dependencies.py — Python

$ Input: recipes = ["bread","sandwich"], ingredients = [["yeast","flour"],["bread","meat"]], supplies = ["yeast","flour","meat"]

› Output: ["bread","sandwich"]

💡 Note: First we make bread using yeast and flour. Then we can make sandwich using the bread we just made plus meat from our supplies. Both recipes are possible.

impossible_recipe.py — Python

$ Input: recipes = ["bread","sandwich"], ingredients = [["yeast","flour"],["bread","meat"]], supplies = ["yeast"]

› Output: []

💡 Note: We can't make bread because we're missing flour. Since bread can't be made, sandwich also can't be made (it needs bread as an ingredient). No recipes are possible.

Constraints

n == recipes.length == ingredients.length
1 ≤ n ≤ 100
1 ≤ ingredients[i].length ≤ 100
1 ≤ supplies.length ≤ 100
1 ≤ recipes[i].length, ingredients[i][j].length, supplies[k].length ≤ 10
All strings consist of only lowercase English letters
Each ingredients[i] does not contain duplicates

Visualization

Tap to expand

Understanding the Visualization

Map Dependencies

Create a graph showing which recipes depend on others

Find Starting Points

Identify recipes that can be made with current supplies

Process in Order

Make recipes and unlock new possibilities

Complete All Possible

Continue until no more recipes can be unlocked

Key Takeaway

🎯 Key Insight: Use topological sorting to handle recipe dependencies efficiently - process recipes in dependency order, unlocking new possibilities as you go!

Asked in

a Amazon 35 G Google 28 f Meta 22 ⊞ Microsoft 15

The optimal solution uses topological sorting to resolve recipe dependencies. We model this as a directed graph where recipes depend on their ingredients, then use Kahn's algorithm to process recipes in the correct order. This achieves O(R + I) time complexity where R is recipes and I is total ingredient relationships.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated Attempts)	O(R² × I)	O(R + S)	Keep trying to make recipes until no new recipes can be created
Topological Sort (Optimal)	O(R + I)	O(R + I)	Use Kahn's algorithm for topological sorting to handle recipe dependencies efficiently

Brute Force (Repeated Attempts) — Algorithm Steps

Start with initial supplies as available ingredients
Repeat: try each recipe to see if all ingredients are available
If recipe can be made, add it to results and mark as available ingredient
Continue until no new recipes are made in a complete pass
Return all successfully made recipes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with supplies: [yeast, flour]. Try all recipes.

First Pass

Can make bread (needs yeast, flour). Add bread to available.

Second Pass

Can make sandwich (needs bread, ham). But no ham available.

No Progress

No new recipes possible. Return [bread].

Code -

solution.c — C

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

// Note: C implementation would require significant string handling
// This is a simplified structure

char** findAllRecipes(char** recipes, int recipesSize, char*** ingredients, int* ingredientSizes, char** supplies, int suppliesSize, int* returnSize) {
    // Complex C implementation needed for string sets
    *returnSize = 0;
    return NULL;
}

int main() {
    // C implementation would require extensive string parsing
    printf("Complex C implementation needed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R² × I)

R recipes × R iterations (worst case) × I average ingredients per recipe

✓ Linear Growth

Space Complexity

O(R + S)

Space for result list and set of available ingredients

✓ Linear Space

39.2K Views

Medium Frequency

~25 min Avg. Time

1.7K 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 (Repeated Attempts) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler