Squirrel Simulation

Squirrel Simulation - Problem

Array Math Medium

You are given two integers height and width representing a garden of size height x width. You are also given:

An array tree where tree = [treer, treec] is the position of the tree in the garden
An array squirrel where squirrel = [squirrelr, squirrelc] is the position of the squirrel in the garden
An array nuts where nuts[i] = [nutir, nutic] is the position of the ith nut in the garden

The squirrel can only take at most one nut at one time and can move in four directions: up, down, left, and right, to the adjacent cell. Return the minimal distance for the squirrel to collect all the nuts and put them under the tree one by one.

The distance is the number of moves.

Input & Output

Example 1 — Basic Garden

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

› Output: 12

💡 Note: Squirrel collects nut at [3,0] first (distance 5), brings to tree (distance 3), then goes to [2,5] (distance 3), and brings back (distance 3). Total: 5+3+3+3 = 14. But optimal is 12 by choosing [2,5] first.

Example 2 — Single Nut

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

› Output: 3

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

Example 3 — Multiple Nuts Close Together

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

› Output: 6

💡 Note: Base distance is 2×(1+1+1) = 6. Best savings comes from choosing optimal first nut, but all have same savings of 0. Total remains 6.

Constraints

1 ≤ height, width ≤ 100
tree.length == 2
squirrel.length == 2
1 ≤ nuts.length ≤ 5000
nuts[i].length == 2
0 ≤ treer, squirrelr, nutir ≤ height
0 ≤ treec, squirrelc, nutic ≤ width

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 f Facebook 6

The key insight is that only the first nut collection order matters for optimization - after collecting the first nut, the squirrel is at the tree, making subsequent order irrelevant. The optimal approach uses mathematical analysis: calculate base distance (2 × sum of all nut-to-tree distances) then subtract maximum savings from choosing the best first nut. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Orders

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

Try every permutation of nuts collection order. For each order, calculate total distance: squirrel to first nut, then each nut to tree, then tree to next nut, and so on.

Mathematical Optimization

⏱️ Time: O(n) Space: O(1)

Key insight: After collecting the first nut, squirrel is at the tree, so the order of remaining nuts doesn't matter. We only need to find which nut to collect first to minimize total distance.

Brute Force - Try All Orders — Algorithm Steps

Generate all permutations of nuts
For each permutation, calculate total distance
Return minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders to collect nuts

Calculate Each Path

For each order, sum distances: squirrel→nut→tree for each nut

Find Minimum

Return the order with smallest total distance

Code -

solution.c — C

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

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int minDistanceGlobal = INT_MAX;

void permute(int* indices, int start, int n, int** nuts, int* tree, int* squirrel) {
    if (start == n) {
        int totalDistance = 0;
        int currentPos[2] = {squirrel[0], squirrel[1]};
        
        for (int i = 0; i < n; i++) {
            int nutIdx = indices[i];
            int* nutPos = nuts[nutIdx];
            totalDistance += manhattanDistance(currentPos, nutPos);
            totalDistance += manhattanDistance(nutPos, tree);
            currentPos[0] = tree[0];
            currentPos[1] = tree[1];
        }
        
        if (totalDistance < minDistanceGlobal) {
            minDistanceGlobal = totalDistance;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&indices[start], &indices[i]);
        permute(indices, start + 1, n, nuts, tree, squirrel);
        swap(&indices[start], &indices[i]);
    }
}

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

int parseIntFromString(char* str, int* pos) {
    int num = 0;
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    while (str[*pos] >= '0' && str[*pos] <= '9') {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    return num * sign;
}

void parseArray(char* str, int* arr) {
    int pos = 1; // Skip '['
    arr[0] = parseIntFromString(str, &pos);
    pos++; // Skip ','
    arr[1] = parseIntFromString(str, &pos);
}

int parse2DArray(char* str, int*** nuts) {
    int count = 0;
    int len = strlen(str);
    
    // Count arrays
    for (int i = 0; i < len; i++) {
        if (str[i] == '[' && i > 0) count++;
    }
    
    *nuts = (int**)malloc(count * sizeof(int*));
    for (int i = 0; i < count; i++) {
        (*nuts)[i] = (int*)malloc(2 * sizeof(int));
    }
    
    int nutIdx = 0;
    for (int i = 1; i < len - 1; i++) {
        if (str[i] == '[') {
            i++; // Skip '['
            int pos = i;
            (*nuts)[nutIdx][0] = parseIntFromString(str, &pos);
            i = pos;
            if (str[i] == ',') i++;
            pos = i;
            (*nuts)[nutIdx][1] = parseIntFromString(str, &pos);
            i = pos;
            while (i < len && str[i] != ']') i++;
            nutIdx++;
        }
    }
    
    return count;
}

int main() {
    int height, width;
    scanf("%d", &height);
    scanf("%d", &width);
    
    int tree[2], squirrel[2];
    char buffer[10000];
    
    scanf("%s", buffer);
    parseArray(buffer, tree);
    
    scanf("%s", buffer);
    parseArray(buffer, squirrel);
    
    scanf("%s", buffer);
    int** nuts;
    int nutsSize = parse2DArray(buffer, &nuts);
    
    int result = solution(height, width, tree, squirrel, nuts, nutsSize);
    printf("%d\n", result);
    
    for (int i = 0; i < nutsSize; i++) {
        free(nuts[i]);
    }
    free(nuts);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each requiring O(n) distance calculations

⚠ Quadratic Growth

Space Complexity

O(n!)

Storing all permutations and recursion stack

⚠ Quadratic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

425 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 Orders — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler