Cut Off Trees for Golf Event - Practice Coding Problems

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

Forest Tree Cutting StrategySStart2Tree H=23Tree H=34Tree H=4①②③BFS ensures shortest paths between treesOrder: Height 2 → Height 3 → Height 4Total minimum steps = Sum of all shortest paths

Understanding the Visualization

Survey the Forest

Find all trees and note their heights - like making a treasure map

Plan the Route

Sort trees by height to determine the required visitation order

Navigate Optimally

Use BFS to find shortest path between consecutive tree locations

Sum Total Distance

Add up all the shortest distances to get minimum total steps

Key Takeaway

🎯 Key Insight: Break the problem into multiple shortest-path subproblems, using BFS to guarantee optimal distances between consecutive trees in height-sorted order.

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

Approach	Time	Space	Notes
✓ Brute Force (DFS for Each Path)	O(4^(mn) t)	O(m*n)	Use DFS to find any path between consecutive trees
BFS Shortest Path (Optimal)	O(t * m * n)	O(m * n)	Use BFS to find shortest path between consecutive trees in height order

Brute Force (DFS for Each Path) — Algorithm Steps

Extract all trees and sort them by height
Start from position (0,0)
For each tree in sorted order, use DFS to find any path
Sum up all path lengths
Return -1 if any path is not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Trees

Locate all trees and sort by height

DFS Search

Use DFS to find path from current position to next tree

Backtrack

If path blocked, backtrack and try different route

Continue

Move to tree location and repeat for next tree

Code -

solution.c — C

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

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

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

int dfs(int** forest, int m, int n, int startR, int startC, 
        int targetR, int targetC, int** visited) {
    if (startR == targetR && startC == targetC) return 0;
    
    visited[startR][startC] = 1;
    int minSteps = INT_MAX;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        int nr = startR + directions[i][0];
        int nc = startC + directions[i][1];
        if (nr >= 0 && nr < m && nc >= 0 && nc < n &&
            forest[nr][nc] != 0 && !visited[nr][nc]) {
            int steps = dfs(forest, m, n, nr, nc, targetR, targetC, visited);
            if (steps != -1 && 1 + steps < minSteps) {
                minSteps = 1 + steps;
            }
        }
    }
    
    visited[startR][startC] = 0;
    return minSteps == INT_MAX ? -1 : minSteps;
}

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);
    
    // Allocate visited array
    int** visited = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        visited[i] = calloc(n, sizeof(int));
    }
    
    int totalSteps = 0;
    int currR = 0, currC = 0;
    
    if (forest[0][0] == 0) {
        free(trees);
        for (int i = 0; i < m; i++) free(visited[i]);
        free(visited);
        return -1;
    }
    
    for (int i = 0; i < treeCount; i++) {
        // Clear visited array
        for (int j = 0; j < m; j++) {
            memset(visited[j], 0, n * sizeof(int));
        }
        
        int steps = dfs(forest, m, n, currR, currC, trees[i].r, trees[i].c, visited);
        if (steps == -1) {
            free(trees);
            for (int j = 0; j < m; j++) free(visited[j]);
            free(visited);
            return -1;
        }
        totalSteps += steps;
        currR = trees[i].r;
        currC = trees[i].c;
    }
    
    free(trees);
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    return totalSteps;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n) * t)

For each of t trees, DFS explores up to 4^(m*n) possible paths in worst case

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth can go up to m*n in worst case

⚡ 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

Brute Force (DFS for Each Path) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler