Cut Off Trees for Golf Event

Cut Off Trees for Golf Event - Problem

Golf Course Forest Clearing Challenge

You're tasked with clearing a forest to create a golf course! The forest is represented as an m × n grid where each cell contains:

• 0 - Obstacle (cannot walk through)
• 1 - Empty space (can walk through)
• Number > 1 - Tree with height (can walk through and cut)

Rules:
1. Start at position (0, 0)
2. Move in 4 directions: north, east, south, west
3. Must cut trees in order from shortest to tallest
4. After cutting a tree, the cell becomes empty (value = 1)

Goal: Return the minimum steps needed to cut all trees, or -1 if impossible.

Example: If you have trees of heights [3, 4, 2], you must cut them in order: height 2 → height 3 → height 4

Input & Output

example_1.py — Basic Forest

$ Input: forest = [[1,2,3],[0,0,4],[7,6,5]]

› Output: 6

💡 Note: Trees to cut: [2,3,4,5,6,7]. Start at (0,0), go to (0,1) for tree 2 (1 step), then (0,2) for tree 3 (1 step), then (1,2) for tree 4 (1 step), then (2,2) for tree 5 (1 step), then (2,1) for tree 6 (1 step), then (2,0) for tree 7 (1 step). Total: 6 steps.

example_2.py — Blocked Path

$ Input: forest = [[1,2,3],[0,0,0],[7,6,5]]

› Output: -1

💡 Note: Trees exist at positions with values > 1, but middle row is all obstacles (0). Cannot reach trees in the bottom row from the top row, so return -1.

example_3.py — Single Tree

$ Input: forest = [[2,1,1],[1,1,1],[1,1,1]]

› Output: 0

💡 Note: Only one tree with height 2 at position (0,0), which is also the starting position. No movement needed, so return 0 steps.

Constraints

1 ≤ forest.length ≤ 50
1 ≤ forest[i].length ≤ 50
0 ≤ forest[i][j] ≤ 10⁹
No two trees have the same height
At least one tree exists

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires finding the minimum steps to cut trees in height order. The optimal approach uses BFS for shortest paths between consecutive trees after sorting by height. Time complexity is O(t × m × n) where t is the number of trees.

Common Approaches

✓ BFS Shortest Path (Optimal)

⏱️ Time: O(t * m * n) Space: O(m * n)

Sort trees by height, then use BFS to find the shortest path from current position to each next tree. BFS guarantees the shortest path in unweighted grids, making this the optimal solution.

Brute Force (DFS for Each Path)

⏱️ Time: O(4^(m*n) * t) Space: O(m*n)

Sort trees by height, then use DFS to find a path from current position to each next tree. This approach may not find the shortest path but will find a valid path if one exists.

BFS Shortest Path (Optimal) — Algorithm Steps

Extract all trees and sort them by height ascending
Start from position (0,0)
For each tree in sorted order, use BFS to find shortest path
BFS explores layer by layer, guaranteeing shortest distance
Sum up all shortest path lengths
Return -1 if any tree is unreachable

Visualization

Tap to expand

BFS Layer-by-Layer✓ Guarantees shortest path✓ Order: Tree(2)→Tree(3)→Tree(4)✓ Total steps: 1 + 1 + 3 = 5Optimal Solution!

Step-by-Step Walkthrough

Sort Trees

Arrange trees by height: [2, 3, 4]

BFS to Tree(2)

Explore neighbors layer by layer from start

BFS to Tree(3)

Find shortest path from Tree(2) to Tree(3)

BFS to Tree(4)

Find shortest path from Tree(3) to Tree(4)

Code -

solution.c — C

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

typedef struct {
    int height, r, c;
} Tree;

typedef struct {
    int r, c, steps;
} QueueItem;

int compare(const void* a, const void* b) {
    return ((Tree*)a)->height - ((Tree*)b)->height;
}

int bfs(int** forest, int m, int n, int startR, int startC, int targetR, int targetC) {
    if (startR == targetR && startC == targetC) return 0;
    
    QueueItem* queue = malloc(m * n * sizeof(QueueItem));
    int** visited = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        visited[i] = calloc(n, sizeof(int));
    }
    
    int front = 0, rear = 0;
    queue[rear++] = (QueueItem){startR, startC, 0};
    visited[startR][startC] = 1;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (front < rear) {
        QueueItem curr = queue[front++];
        
        for (int i = 0; i < 4; i++) {
            int nr = curr.r + directions[i][0];
            int nc = curr.c + directions[i][1];
            
            if (nr >= 0 && nr < m && nc >= 0 && nc < n &&
                forest[nr][nc] != 0 && !visited[nr][nc]) {
                
                if (nr == targetR && nc == targetC) {
                    free(queue);
                    for (int j = 0; j < m; j++) free(visited[j]);
                    free(visited);
                    return curr.steps + 1;
                }
                
                visited[nr][nc] = 1;
                queue[rear++] = (QueueItem){nr, nc, curr.steps + 1};
            }
        }
    }
    
    free(queue);
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    return -1;
}

int cutOffTree(int** forest, int forestSize, int* forestColSize) {
    if (forestSize == 0 || forestColSize[0] == 0) return -1;
    
    int m = forestSize, n = forestColSize[0];
    
    // Find all trees
    Tree* trees = malloc(m * n * sizeof(Tree));
    int treeCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (forest[i][j] > 1) {
                trees[treeCount++] = (Tree){forest[i][j], i, j};
            }
        }
    }
    
    qsort(trees, treeCount, sizeof(Tree), compare);
    
    int totalSteps = 0;
    int currR = 0, currC = 0;
    
    if (forest[0][0] == 0) {
        free(trees);
        return -1;
    }
    
    for (int i = 0; i < treeCount; i++) {
        int steps = bfs(forest, m, n, currR, currC, trees[i].r, trees[i].c);
        if (steps == -1) {
            free(trees);
            return -1;
        }
        totalSteps += steps;
        currR = trees[i].r;
        currC = trees[i].c;
    }
    
    free(trees);
    return totalSteps;
}

Time & Space Complexity

Time Complexity

⏱️

O(t * m * n)

For each of t trees, BFS visits at most m*n cells once. Total: t * m * n operations

✓ Linear Growth

Space Complexity

O(m * n)

BFS queue can contain at most m*n cells, plus visited array of size m*n

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

BFS Shortest Path (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler