Maximum Total Damage With Spell Casting

Maximum Total Damage With Spell Casting - Problem

Array Hash Table Two Pointers Binary Search Dynamic Programming Sorting Counting Medium

A magician has various spells. You are given an array power, where each element represents the damage of a spell. Multiple spells can have the same damage value.

It is a known fact that if a magician decides to cast a spell with a damage of power[i], they cannot cast any spell with a damage of power[i] - 2, power[i] - 1, power[i] + 1, or power[i] + 2.

Each spell can be cast only once. Return the maximum possible total damage that a magician can cast.

Input & Output

Example 1 — Basic Case

$ Input: power = [1,1,3,4]

› Output: 6

💡 Note: We can cast both spells with damage 1 and the spell with damage 4. The spell with damage 4 conflicts with damage 2,3,5,6 (which don't exist or can't be cast), so we can cast damage 1 twice and damage 4 once. Total = 1 + 1 + 4 = 6. We cannot include damage 3 because it conflicts with damage 1 and 4.

Example 2 — Multiple Same Values

$ Input: power = [7,1,6,6]

› Output: 13

💡 Note: We can cast both spells with damage 6 and the spell with damage 1. Total = 6 + 6 + 1 = 13. We cannot include damage 7 because it conflicts with damage 6.

Example 3 — All Consecutive

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

› Output: 5

💡 Note: All damages are consecutive and conflict with each other. The best strategy is to pick the single highest damage spell: 5.

Constraints

1 ≤ power.length ≤ 10⁵
1 ≤ power[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 a Amazon 10

The key insight is to group spells by damage value and treat this as a house robber problem with constraint distance of 2. After counting frequencies and sorting, use dynamic programming where each damage value is either fully taken or skipped. Best approach uses binary search for optimal transitions. Time: O(n log k), Space: O(k).

Common Approaches

✓ Brute Force (Backtracking)

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

For each spell, we have two choices: cast it (and mark conflicting spells as unusable) or skip it. We recursively explore all possibilities and return the maximum damage.

Frequency Count + Sorting

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

Count frequency of each spell damage, sort unique damages, then use DP where for each damage value we decide to take all instances or skip them based on constraint.

Optimized Dynamic Programming

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

After grouping by frequency, treat this as a variation of house robber where we can't rob houses within distance 2. Use DP with optimal transition.

Brute Force (Backtracking) — Algorithm Steps

Try casting each spell
Mark conflicting spells as unusable
Recursively solve remaining subproblem
Return maximum of casting vs skipping

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with all spells available

Branch

For each spell: cast it or skip it

Constrain

Mark conflicting spells as unusable

Result

Return maximum damage found

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 compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* power, int n) {
    if (n == 0) return 0;

    int uniquePowers[1000];
    int damageCount[1000];
    int uniqueCount = 0;

    int sortedPower[1000];
    for (int i = 0; i < n; i++) sortedPower[i] = power[i];
    qsort(sortedPower, n, sizeof(int), compare);

    int cur = sortedPower[0];
    int count = 1;
    for (int i = 1; i < n; i++) {
        if (sortedPower[i] == cur) {
            count++;
        } else {
            uniquePowers[uniqueCount] = cur;
            damageCount[uniqueCount] = count;
            uniqueCount++;
            cur = sortedPower[i];
            count = 1;
        }
    }
    uniquePowers[uniqueCount] = cur;
    damageCount[uniqueCount] = count;
    uniqueCount++;

    int dp[1000];
    dp[0] = uniquePowers[0] * damageCount[0];

    if (uniqueCount == 1) return dp[0];

    int curDamage = uniquePowers[1] * damageCount[1];
    // Conflict if difference < 3 (i.e., difference is 1 or 2)
    if (uniquePowers[1] - uniquePowers[0] < 3) {
        dp[1] = max(dp[0], curDamage);
    } else {
        dp[1] = dp[0] + curDamage;
    }

    for (int i = 2; i < uniqueCount; i++) {
        int cp = uniquePowers[i];
        curDamage = cp * damageCount[i];

        // Option 1: skip current
        dp[i] = dp[i - 1];

        // Option 2: take current — find last non-conflicting index
        // Conflict when difference < 3, so scan back while conflicting
        int j = i - 1;
        while (j >= 0 && cp - uniquePowers[j] < 3) {
            j--;
        }

        if (j >= 0) {
            dp[i] = max(dp[i], dp[j] + curDamage);
        } else {
            dp[i] = max(dp[i], curDamage);
        }
    }

    return dp[uniqueCount - 1];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);

    int power[1000];
    int n = 0;
    parseArray(line, power, &n);

    printf("%d\n", solution(power, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each spell has 2 choices (cast or skip), leading to 2^n combinations

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth up to n levels

✓ Linear Space

23.4K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler