# Solving Leetcode Interviews in Seconds with AI: Maximum Total Damage With Spell Casting


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3186" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: power = [1,1,3,4] Output: 6 Explanation: The maximum possible damage of 6 is produced by casting spells 0, 1, 3 with damage 1, 1, 4.  Example 2:  Input: power = [7,1,6,6] Output: 13 Explanation: The maximum possible damage of 13 is produced by casting spells 1, 2, 3 with damage 1, 6, 6.    Constraints:  1 <= power.length <= 105 1 <= power[i] <= 109  

	# Explanation
	Here's the breakdown of the solution:

*   **Sort and Dynamic Programming:** Sort the spell damages to efficiently consider them in ascending order. Then, use dynamic programming to calculate the maximum damage achievable up to each spell.
*   **State Transition:** For each spell, decide whether to include it in the optimal set or not. If a spell is included, spells with damages power\[i] - 2, power\[i] - 1, power\[i] + 1, power\[i] + 2 cannot be included.
*   **Optimization:** Use a dictionary (or hash map) to store and retrieve previously calculated maximum damages to avoid redundant computations and optimize performance.

*   **Runtime Complexity:** O(n log n), where n is the number of spells, due to sorting.
*   **Storage Complexity:** O(n), where n is the number of spells, due to the dp dictionary.

	
	# Code
	```python
	def max_damage(power):
    """
    Calculates the maximum possible total damage that a magician can cast,
    given the constraint that if a spell with damage power[i] is cast,
    spells with damage power[i] - 2, power[i] - 1, power[i] + 1, or power[i] + 2 cannot be cast.

    Args:
      power: A list of integers representing the damage of each spell.

    Returns:
      The maximum possible total damage that a magician can cast.
    """

    power.sort()
    n = len(power)
    dp = {}  # Dictionary to store computed results

    def solve(i):
        if i >= n:
            return 0

        if i in dp:
            return dp[i]

        # Option 1: Don't include power[i]
        option1 = solve(i + 1)

        # Option 2: Include power[i]
        current_power = power[i]
        next_index = i + 1
        while next_index < n and (power[next_index] == current_power or power[next_index] == current_power + 1 or power[next_index] == current_power + 2):
            next_index += 1

        option2 = power[i] + solve(next_index)
        dp[i] = max(option1, option2)
        return dp[i]

    return solve(0)
	```