Minimum Runes to Add to Cast Spell

Minimum Runes to Add to Cast Spell - Problem

Array Depth-First Search Breadth-First Search Union Find Graph Topological Sort Hard

Alice has just graduated from wizard school and wishes to cast a magic spell to celebrate. The magic spell contains certain focus points where magic needs to be concentrated, and some of these focus points contain magic crystals which serve as the spell's energy source.

Focus points can be linked through directed runes, which channel magic flow from one focus point to another. You are given an integer n denoting the number of focus points and an array of integers crystals where crystals[i] indicates a focus point which holds a magic crystal.

You are also given two integer arrays flowFrom and flowTo, which represent the existing directed runes. The i-th rune allows magic to freely flow from focus point flowFrom[i] to focus point flowTo[i].

You need to find the number of directed runes Alice must add to her spell, such that each focus point either:

Contains a magic crystal, OR
Receives magic flow from another focus point

Return the minimum number of directed runes that she should add.

Input & Output

Example 1 — Basic Magic Spell

$ Input: n = 4, crystals = [0], flowFrom = [1], flowTo = [2]

› Output: 2

💡 Note: Focus point 0 has a crystal (satisfied). Focus point 2 receives flow from point 1 (satisfied). Focus points 1 and 3 need additional runes to be satisfied, so answer is 2.

Example 2 — Multiple Crystals

$ Input: n = 3, crystals = [0, 2], flowFrom = [], flowTo = []

› Output: 1

💡 Note: Focus points 0 and 2 have crystals (satisfied). Focus point 1 has no crystal and receives no flow, so needs 1 additional rune.

Example 3 — All Satisfied

$ Input: n = 2, crystals = [0], flowFrom = [0], flowTo = [1]

› Output: 0

💡 Note: Focus point 0 has a crystal and focus point 1 receives flow from point 0. All points are satisfied, so no additional runes needed.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ crystals.length ≤ n
0 ≤ crystals[i] < n
0 ≤ flowFrom.length = flowTo.length ≤ 10⁵
0 ≤ flowFrom[i], flowTo[i] < n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that each focus point must either contain a crystal OR receive magic flow from another point. The optimal solution uses set theory: create a set of all satisfied nodes (those with crystals + those receiving flow), then subtract from total nodes. Time: O(n + m), Space: O(n)

Common Approaches

✓ Brute Force Check

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

For each focus point, check if it has a crystal or receives flow from any other point. Count how many points need additional incoming runes.

DFS Reachability Analysis

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

Build a graph from existing runes, then use DFS from each crystal node to find all reachable nodes. Any unreachable node needs a new rune connection.

Optimal Set Theory Solution

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

The key insight is that every node must either have a crystal OR receive incoming flow. We simply count nodes that satisfy neither condition.

Brute Force Check — Algorithm Steps

Step 1: Mark all focus points with crystals as satisfied
Step 2: Mark all focus points that receive flow as satisfied
Step 3: Count unsatisfied points

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Crystal Nodes

Identify nodes with crystals as satisfied

Mark Flow Targets

Mark nodes that receive flow as satisfied

Count Unsatisfied

Count remaining nodes that need runes

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int n, int* crystals, int crystalsSize, int* flowFrom, int flowFromSize, int* flowTo, int flowToSize) {
    // Mark nodes with crystals as satisfied
    bool* satisfied = (bool*)calloc(n, sizeof(bool));
    for (int i = 0; i < crystalsSize; i++) {
        satisfied[crystals[i]] = true;
    }
    
    // Mark nodes that receive flow as satisfied
    for (int i = 0; i < flowToSize; i++) {
        satisfied[flowTo[i]] = true;
    }
    
    // Count unsatisfied nodes
    int runesNeeded = 0;
    for (int i = 0; i < n; i++) {
        if (!satisfied[i]) {
            runesNeeded++;
        }
    }
    
    free(satisfied);
    return runesNeeded;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    int crystals[1000], flowFrom[1000], flowTo[1000];
    int crystalsSize, flowFromSize, flowToSize;
    
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    parseArray(line, crystals, &crystalsSize);
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, flowFrom, &flowFromSize);
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, flowTo, &flowToSize);
    
    int result = solution(n, crystals, crystalsSize, flowFrom, flowFromSize, flowTo, flowToSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each of n nodes and m edges once

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track satisfied nodes

⚡ Linearithmic Space

23.4K 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 Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler