Dungeon Game - Practice Coding Problems

Dungeon Game - Problem

Imagine a brave knight on a heroic quest to rescue a princess trapped in a dangerous dungeon! 🏰⚔️

The dungeon is represented as an m x n grid where each room contains either:

Demons (negative values) - damage the knight's health
Magic orbs (positive values) - restore the knight's health
Empty rooms (0) - no effect on health

The knight starts at the top-left corner [0,0] and must reach the princess at the bottom-right corner [m-1,n-1]. The knight can only move right or down at each step.

Critical Rule: If the knight's health drops to 0 or below at any point, he dies immediately! 💀

Your task is to determine the minimum initial health the knight needs to successfully rescue the princess, ensuring his health never drops to 0 or below during the journey.

Input & Output

example_1.py — Classic Dungeon

$ Input: [[-4,5,2],[1,-4,0]]

› Output: 7

💡 Note: The optimal path is Right→Down→Right. Starting with 7 HP: at (-4) we have 3 HP, at (-4) we have 4 HP, at (0) we still have 4 HP. Any less initial health would cause death at some point.

example_2.py — Single Positive Cell

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

› Output: 1

💡 Note: All rooms contain positive values or are empty, so we only need the minimum possible health of 1 to start with.

example_3.py — Single Cell Dungeon

$ Input: [[-5]]

› Output: 6

💡 Note: The knight faces a -5 damage in the only room. He needs at least 6 initial health to survive: 6 + (-5) = 1 HP remaining.

Constraints

1 ≤ m, n ≤ 200
-1000 ≤ dungeon[i][j] ≤ 1000
The knight can only move right or down
Health must remain ≥ 1 at all times

Visualization

Tap to expand

Understanding the Visualization

Start at the Destination

Begin planning from the princess's cell - what's the minimum health needed to survive that final encounter?

Plan the Final Approach

Work backwards through the last row and column, where the knight has limited movement options

Map the Optimal Strategy

For each remaining cell, calculate minimum health by considering both possible next moves

Determine Starting Strength

The top-left cell reveals the exact initial health needed for a successful rescue!

Key Takeaway

🎯 Key Insight: By working backwards from the destination, we can determine the exact minimum health needed at each position, leading to an optimal O(m×n) solution that guarantees the knight's successful rescue mission!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Dynamic Programming with a backwards approach. Instead of moving forward from start to finish, we work backwards from the princess's location, calculating the minimum health needed at each cell to survive the remaining journey. The key insight is that we can only determine required health if we know what challenges lie ahead. Time: O(m×n), Space: O(m×n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(m × n)	O(m × n)	Work backwards from destination, calculating minimum required health for each cell
Brute Force (Try All Paths)	O(2^(m+n))	O(m+n)	Generate all possible paths and find minimum initial health for each

Dynamic Programming (Bottom-Up) — Algorithm Steps

Start from the bottom-right corner (princess's location)
For each cell, calculate minimum health needed after visiting that cell
Work backwards row by row, considering both possible next moves (right and down)
The answer is the minimum initial health needed at the starting position

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Princess

Calculate minimum health needed at the final room

Fill Last Row & Column

Handle boundary cases where only one direction is possible

Fill Remaining Cells

For each cell, take minimum of (right, down) paths

Get Answer

Top-left cell contains the minimum initial health needed

Code -

solution.c — C

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

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

int min(int a, int b) {
    return a < b ? a : b;
}

int calculateMinimumHP(int** dungeon, int m, int n) {
    // Create DP table
    int** dp = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dp[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Start from bottom-right (princess location)
    dp[m-1][n-1] = max(1, 1 - dungeon[m-1][n-1]);
    
    // Fill last row (can only move right)
    for (int j = n-2; j >= 0; j--) {
        dp[m-1][j] = max(1, dp[m-1][j+1] - dungeon[m-1][j]);
    }
    
    // Fill last column (can only move down)
    for (int i = m-2; i >= 0; i--) {
        dp[i][n-1] = max(1, dp[i+1][n-1] - dungeon[i][n-1]);
    }
    
    // Fill the rest of the table
    for (int i = m-2; i >= 0; i--) {
        for (int j = n-2; j >= 0; j--) {
            int minHealthNeeded = min(dp[i+1][j], dp[i][j+1]);
            dp[i][j] = max(1, minHealthNeeded - dungeon[i][j]);
        }
    }
    
    int result = dp[0][0];
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell exactly once in the grid

✓ Linear Growth

Space Complexity

O(m × n)

DP table to store minimum health needed for each cell

⚡ Linearithmic Space

73.9K Views

Medium-High 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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler