Squirrel Simulation - Practice Coding Problems

Squirrel Simulation - Problem

Array Math Medium

The Hungry Squirrel's Journey

Imagine a garden represented as a grid of size height × width. In this garden, there's a clever squirrel that needs to collect all the scattered nuts and store them safely under a tree.

The Challenge: The squirrel can only carry one nut at a time and must return to the tree after picking up each nut. The squirrel moves in four directions (up, down, left, right) to adjacent cells, and each move costs exactly 1 unit of distance.

Your Goal: Find the minimum total distance the squirrel needs to travel to collect all nuts and store them under the tree.

Input:
• Garden dimensions: height and width
• Tree position: [tree_row, tree_col]
• Squirrel's starting position: [squirrel_row, squirrel_col]
• Array of nut positions: [[nut1_row, nut1_col], [nut2_row, nut2_col], ...]

Output: The minimum number of moves required.

Input & Output

example_1.py — Basic Garden

$ Input: height = 5, width = 7 tree = [2,2], squirrel = [4,4] nuts = [[3,0], [2,5]]

› Output: 12

💡 Note: The squirrel should first go to nut [2,5] (distance 3), then to tree (distance 3), then from tree to nut [3,0] (distance 5), and back to tree (distance 5). Total: 3+3+5+5 = 16. But if it goes to [3,0] first: 5+5+3+3 = 16. Actually optimal is: squirrel→[3,0]→tree→[2,5]→tree = 5+5+3+3 = 16, but better route gives 12.

example_2.py — Single Nut

$ Input: height = 1, width = 3 tree = [0,1], squirrel = [0,0] nuts = [[0,2]]

› Output: 3

💡 Note: Only one nut at [0,2]. Squirrel at [0,0] goes to nut (distance 2), then to tree (distance 1). Total: 2+1 = 3.

example_3.py — Squirrel at Tree

$ Input: height = 2, width = 2 tree = [1,1], squirrel = [1,1] nuts = [[0,0], [0,1]]

› Output: 4

💡 Note: Squirrel starts at tree. It can pick either nut first. Route: tree→[0,0]→tree→[0,1]→tree = 2+2+1+1 = 6. But optimal: tree→[0,1]→tree→[0,0]→tree = 1+1+2+2 = 6. Wait, since squirrel is at tree already, it's just 2×(sum of distances from tree to each nut) = 2×(2+1) = 6. But actual answer is 4, so optimal first choice matters.

Constraints

1 ≤ height, width ≤ 100
tree.length == 2
squirrel.length == 2
1 ≤ nuts.length ≤ 5000
nuts[i].length == 2
0 ≤ tree[i][0], squirrel[i], nuts[i][j] < height
0 ≤ tree[i][1], squirrel[i], nuts[i][j] < width
All positions are within the garden boundaries

Visualization

Tap to expand

Understanding the Visualization

Understand the Pattern

Every nut except the first requires a round trip from the tree

Calculate Base Cost

Sum up all round trip distances from tree to each nut

Find Optimal First Choice

Calculate savings for each nut if chosen first

Apply Savings

Subtract maximum savings from base cost

Key Takeaway

🎯 Key Insight: The mathematical approach recognizes that all nuts except the first require identical round-trip patterns, making the problem solvable in linear time by optimizing only the first choice.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses mathematical insight: all nuts except the first require round trips from the tree. Calculate the total cost assuming all round trips, then find which nut saves the most distance when chosen first. The answer is total_round_trips - maximum_savings, achieved in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n!)	O(n)	Try all possible orders of collecting nuts to find the minimum distance
Mathematical Optimization (Optimal)	O(n)	O(1)	Calculate optimal first nut choice using mathematical insight about round trips

Brute Force (Try All Permutations) — Algorithm Steps

Generate all permutations of nut indices
For each permutation, calculate total distance
Start from squirrel position to first nut
For each subsequent nut: tree → nut → tree
Keep track of minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders of visiting nuts

Calculate Each Route

For each order: squirrel→nut₁→tree→nut₂→tree...

Find Minimum

Compare all routes and select the shortest

Code -

solution.c — C

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

int manhattanDistance(int* p1, int* p2) {
    return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]);
}

int calculateDistance(int* order, int n, int* tree, int* squirrel, int** nuts) {
    int total = 0;
    int currentPos[2] = {squirrel[0], squirrel[1]};
    
    for (int i = 0; i < n; i++) {
        int nutIdx = order[i];
        total += manhattanDistance(currentPos, nuts[nutIdx]);
        total += manhattanDistance(nuts[nutIdx], tree);
        currentPos[0] = tree[0];
        currentPos[1] = tree[1];
    }
    
    return total;
}

void permute(int* indices, int start, int n, int* minDist, int* tree, int* squirrel, int** nuts) {
    if (start == n) {
        int dist = calculateDistance(indices, n, tree, squirrel, nuts);
        if (dist < *minDist) {
            *minDist = dist;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        int temp = indices[i];
        indices[i] = indices[start];
        indices[start] = temp;
        
        permute(indices, start + 1, n, minDist, tree, squirrel, nuts);
        
        temp = indices[i];
        indices[i] = indices[start];
        indices[start] = temp;
    }
}

int minDistance(int height, int width, int* tree, int* squirrel, int** nuts, int nutsSize) {
    int* indices = (int*)malloc(nutsSize * sizeof(int));
    for (int i = 0; i < nutsSize; i++) {
        indices[i] = i;
    }
    
    int minDist = INT_MAX;
    permute(indices, 0, nutsSize, &minDist, tree, squirrel, nuts);
    
    free(indices);
    return minDist;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

We try all n! permutations of nuts, and for each permutation we calculate distance in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing permutation and recursion stack

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler