Taking Maximum Energy From the Mystic Dungeon

Taking Maximum Energy From the Mystic Dungeon - Problem

In a mystical dungeon, n magicians stand in a line, each possessing unique magical energy that can either boost your power or drain your strength. You've been cursed with a teleportation spell that forces you to jump exactly k positions after absorbing energy from each magician.

Here's how it works:

Choose any starting position i
Absorb the magician's energy (positive or negative)
Teleport to position i + k
Repeat until you can't jump anymore (when i + k ≥ n)

Goal: Find the starting position that gives you the maximum total energy possible.

Example: With energy = [5, 2, -3, 1, -4] and k = 2, starting at index 0 gives you: 5 + (-3) + (-4) = -2, while starting at index 1 gives you: 2 + 1 = 3.

Input & Output

example_1.py — Basic Case

$ Input: energy = [5, 2, -3, 1, -4], k = 2

› Output: 3

💡 Note: Starting at index 1: 2 → 1 (sum = 3). Starting at index 0: 5 → -3 → -4 (sum = -2). The maximum is 3.

example_2.py — All Positive

$ Input: energy = [1, 2, 3, 4], k = 1

› Output: 10

💡 Note: With k=1, we visit every element in sequence. Starting from any position gives us the sum of all elements: 1+2+3+4 = 10.

example_3.py — Large Jump

$ Input: energy = [5, -2, -3], k = 3

› Output: 5

💡 Note: Starting at index 0: only visit 5 (no more jumps possible). Starting at index 1: only visit -2. Starting at index 2: only visit -3. Maximum is 5.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ k ≤ n
-1000 ≤ energy[i] ≤ 1000
You must absorb energy from every magician you visit

Visualization

Tap to expand

Understanding the Visualization

Choose starting position

Pick any magician from position 0 to n-1 as your starting point

Absorb and teleport

Take the magician's energy (positive or negative) and jump k positions forward

Repeat until end

Continue the process until you can't jump k positions anymore

Find maximum

The goal is to find the starting position that gives maximum total energy

Key Takeaway

🎯 Key Insight: Since we can only jump k positions at a time, there are at most k unique jumping patterns. We can optimize by calculating each pattern once using dynamic programming.

Asked in

f Meta 25 a Amazon 18 G Google 15 ⊞ Microsoft 12

The optimal approach uses dynamic programming with suffix sums. Key insight: there are only k possible jumping sequences, so we work backwards computing the maximum energy for each starting position in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Starting Positions)	O(n²)	O(1)	Try every possible starting position and calculate the total energy for each path
Optimized Single Pass (Suffix Sum)	O(n)	O(k)	Calculate suffix sums in reverse order to find maximum energy efficiently

Brute Force (Try All Starting Positions) — Algorithm Steps

Initialize maxEnergy to negative infinity
For each starting position i from 0 to n-1:
Initialize currentSum to 0 and position to i
While position is within bounds:
Add energy[position] to currentSum
Move to position + k
Update maxEnergy with the maximum of maxEnergy and currentSum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Calculate sum by jumping k positions: 0 → k → 2k → ...

Start at position 1

Calculate sum by jumping k positions: 1 → 1+k → 1+2k → ...

Continue for all positions

Try every starting position from 0 to n-1

Return maximum

Compare all sums and return the highest value

Code -

solution.c — C

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

int maximumEnergy(int* energy, int n, int k) {
    int maxEnergy = INT_MIN;
    
    for (int start = 0; start < n; start++) {
        int currentSum = 0;
        int pos = start;
        
        while (pos < n) {
            currentSum += energy[pos];
            pos += k;
        }
        
        if (currentSum > maxEnergy) {
            maxEnergy = currentSum;
        }
    }
    
    return maxEnergy;
}

int main() {
    int energy[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &energy[n], &c) && n < 999) {
        n++;
        if (c == '\n') break;
    }
    int k;
    scanf("%d", &k);
    printf("%d\n", maximumEnergy(energy, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case when k=1, we try n starting positions and each path can be up to n elements long

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current sum and maximum energy

✓ Linear Space

28.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 (Try All Starting Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler