Dungeon Game

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: 5

💡 Note: The optimal path is Right→Down→Right. Starting with 5 HP: at (-4) we have 1 HP, at (5) we have 6 HP, at (-4) we have 2 HP, at (0) we still have 2 HP. Any less initial health would cause death at the first cell.

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

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

✓ Brute Force (Try All Paths)

⏱️ Time: O(2^(m+n)) Space: O(m+n)

This approach explores every possible path from top-left to bottom-right, simulating the knight's journey and tracking the minimum health needed. For each path, we calculate what initial health would be required to never drop below 1.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(m × n) Space: O(m × n)

This is the optimal approach that uses dynamic programming by working backwards from the princess's location. For each cell, we calculate the minimum health needed to survive the rest of the journey. The key insight is that we can only determine the required health if we know what challenges lie ahead.

Brute Force (Try All Paths) — Algorithm Steps

Generate all possible paths using recursion (only right and down moves)
For each complete path, simulate the journey and track minimum health reached
Calculate required initial health for each path
Return the minimum initial health across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Exploration

Begin at top-left, track all possible paths

Branch at Each Cell

At each cell, try both right and down moves

Reach Destination

Calculate required initial health for each complete path

Find Minimum

Return the minimum initial health across all paths

Code -

solution.c — C

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

int minHealth = INT_MAX;

void dfs(int** dungeon, int m, int n, int i, int j, int* path, int pathLen) {
    if (i == m - 1 && j == n - 1) {
        // Calculate minimum initial health for this path
        int health = 0;
        int minDuringPath = 0;
        
        // Process current path
        for (int k = 0; k < pathLen; k++) {
            health += path[k];
            if (health < minDuringPath) {
                minDuringPath = health;
            }
        }
        // Add final room
        health += dungeon[i][j];
        if (health < minDuringPath) {
            minDuringPath = health;
        }
        
        int requiredInitial = 1 - minDuringPath;
        if (requiredInitial < minHealth) {
            minHealth = requiredInitial;
        }
        return;
    }
    
    // Move right
    if (j + 1 < n) {
        path[pathLen] = dungeon[i][j];
        dfs(dungeon, m, n, i, j + 1, path, pathLen + 1);
    }
    
    // Move down
    if (i + 1 < m) {
        path[pathLen] = dungeon[i][j];
        dfs(dungeon, m, n, i + 1, j, path, pathLen + 1);
    }
}

int calculateMinimumHP(int** dungeon, int m, int n) {
    minHealth = INT_MAX;
    int* path = (int*)malloc((m + n) * sizeof(int));
    dfs(dungeon, m, n, 0, 0, path, 0);
    free(path);
    return minHealth;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array - simple parser for the given format
    int m = 1; // Count rows
    for (int i = 0; line[i]; i++) {
        if (line[i] == ']' && line[i+1] == ',' && line[i+2] == '[') m++;
    }
    
    int** dungeon = (int**)malloc(m * sizeof(int*));
    int* colCounts = (int*)malloc(m * sizeof(int));
    
    // Parse each row
    char* ptr = line + 1; // Skip first '['
    for (int row = 0; row < m; row++) {
        if (*ptr == '[') ptr++; // Skip row start bracket
        
        // Count columns in this row
        int cols = 0;
        char* temp = ptr;
        while (*temp && *temp != ']') {
            if (*temp == ',' || (*temp >= '0' && *temp <= '9') || *temp == '-') {
                if (*temp != ',') {
                    cols++;
                    // Skip to next comma or bracket
                    while (*temp && *temp != ',' && *temp != ']') temp++;
                } else {
                    temp++;
                }
            } else {
                temp++;
            }
        }
        if (cols == 0 && (*ptr >= '0' && *ptr <= '9' || *ptr == '-')) cols = 1;
        
        colCounts[row] = cols;
        dungeon[row] = (int*)malloc(cols * sizeof(int));
        
        // Parse numbers in this row
        int col = 0;
        while (*ptr && *ptr != ']' && col < cols) {
            if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                dungeon[row][col] = (int)strtol(ptr, &ptr, 10);
                col++;
            } else {
                ptr++;
            }
        }
        
        // Skip to next row
        while (*ptr && *ptr != '[' && row < m - 1) ptr++;
    }
    
    int result = calculateMinimumHP(dungeon, m, colCounts[0]);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(dungeon[i]);
    }
    free(dungeon);
    free(colCounts);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

Each cell has 2 choices (right or down), and path length is m+n-1

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack depth equals the path length

⚡ 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

Brute Force (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler