Maximum Total Damage With Spell Casting - Practice Coding Problems

Maximum Total Damage With Spell Casting - Problem

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

🧙‍♂️ A powerful magician has a spellbook filled with various magical spells, each dealing a specific amount of damage. You are given an array power where each element represents the damage value of a spell. Multiple spells can have the same damage value.

However, there's a crucial magical constraint: if a magician casts a spell with damage power[i], the magical interference prevents them from casting any spell with damage values power[i] - 2, power[i] - 1, power[i] + 1, or power[i] + 2.

Each spell can only be cast once, and your goal is to determine the maximum possible total damage the magician can achieve by strategically selecting which spells to cast.

Example: If you have spells with damage [2, 3, 4, 9], you cannot cast both damage-2 and damage-4 spells together (since |2-4| ≤ 2), but you can cast damage-2 and damage-9 together.

Input & Output

example_1.py — Basic Case

$ Input: [2, 3, 4, 9]

› Output: 11

💡 Note: We can cast spells with damage 2 and 9. We cannot cast damage 3 or 4 together with damage 2 since |2-3|=1 ≤ 2 and |2-4|=2 ≤ 2. The spell with damage 9 doesn't conflict with damage 2 since |2-9|=7 > 2.

example_2.py — Duplicate Values

$ Input: [1, 1, 6, 9]

› Output: 17

💡 Note: We can cast both spells with damage 1 (total contribution: 2), the spell with damage 6 (contribution: 6), and the spell with damage 9 (contribution: 9). None of these conflict: |1-6|=5 > 2, |1-9|=8 > 2, |6-9|=3 > 2. Total: 2 + 6 + 9 = 17.

example_3.py — All Conflict

$ Input: [1, 2, 3]

› Output: 3

💡 Note: All spells conflict with each other since |1-2|=1 ≤ 2, |1-3|=2 ≤ 2, and |2-3|=1 ≤ 2. We can only choose one spell, so we choose the one with maximum damage: 3.

Constraints

1 ≤ power.length ≤ 10⁵
1 ≤ power[i] ≤ 10⁹
Each spell can be cast only once
Multiple spells can have the same damage value

Visualization

Tap to expand

Understanding the Visualization

Group Similar Spells

Count how many spells you have of each damage type

Sort by Power

Arrange spell types in ascending order of damage

Dynamic Selection

For each spell type, decide: take all of this type + best from compatible previous types, or skip and take the best from the previous type

Key Takeaway

🎯 Key Insight: Transform the problem into dynamic programming by grouping identical damage values and applying the classic 'non-adjacent selection with gap constraint' pattern on sorted unique values.

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 24

The optimal solution uses dynamic programming with frequency counting. First, count the frequency of each damage value using a hash map. Then, extract and sort the unique damage values. Apply DP where for each unique damage value, we decide whether to take all spells with that damage (contributing damage × count) or skip them, considering that we cannot take damage values that are within 2 of each other. The time complexity is O(n log k) where k is the number of unique damage values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n²)	O(n)	Generate all possible spell combinations and check validity
Dynamic Programming with Counting (Optimal)	O(n log n)	O(k)	Count spell frequencies, then use DP on sorted unique damage values

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n possible combinations of spells
For each combination, check if any two spells conflict
If no conflicts exist, calculate total damage
Track the maximum damage across all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^n possible spell combinations using bit masks

Check Conflicts

For each combination, verify no two spells have damage difference ≤ 2

Track Maximum

Keep track of the highest total damage from valid combinations

Code -

solution.c — C

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

int maxTotalDamage(int* power, int n) {
    int maxDamage = 0;
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        int currentSpells[1000];
        int spellCount = 0;
        int totalDamage = 0;
        
        // Build current combination
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentSpells[spellCount++] = power[i];
                totalDamage += power[i];
            }
        }
        
        // Check for conflicts
        int valid = 1;
        for (int i = 0; i < spellCount && valid; i++) {
            for (int j = i + 1; j < spellCount; j++) {
                if (abs(currentSpells[i] - currentSpells[j]) <= 2) {
                    valid = 0;
                    break;
                }
            }
        }
        
        if (valid && totalDamage > maxDamage) {
            maxDamage = totalDamage;
        }
    }
    
    return maxDamage;
}

int main() {
    int power[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &power[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", maxTotalDamage(power, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n²)

2^n subsets, each requiring O(n²) conflict checking

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current combination and recursion stack

⚡ Linearithmic Space

41.2K Views

Medium Frequency

~25 min Avg. Time

1.8K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler