Island Perimeter

Island Perimeter - Problem

You are given a row x col grid representing a map where grid[i][j] = 1 represents land and grid[i][j] = 0 represents water.

Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells).

The island doesn't have "lakes", meaning the water inside isn't connected to the water around the island. One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100.

Determine the perimeter of the island.

Input & Output

Example 1 — Small Island

$ Input: grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]

› Output: 16

💡 Note: The island has an irregular shape. Each land cell contributes edges that face water or boundaries. Total perimeter is 16.

Example 2 — Single Cell

$ Input: grid = [[1]]

› Output: 4

💡 Note: A single land cell has 4 edges, all facing the boundary (water), so perimeter is 4.

Example 3 — Square Island

$ Input: grid = [[1,1],[1,1]]

› Output: 8

💡 Note: A 2x2 square island. Each of the 4 cells contributes 2 edges to the perimeter (4×2=8).

Constraints

row, col ≤ 100
grid[i][j] is 0 or 1
There is exactly one island

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is that each land cell contributes 4 edges minus the number of adjacent land cells. The most intuitive approach is to check each land cell's 4 directions and count edges facing water or boundaries. Time: O(m×n), Space: O(1).

Common Approaches

✓ Count All Edges

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

Iterate through every cell in the grid. For each land cell, check all 4 directions (up, down, left, right). Count an edge if the adjacent cell is water or outside the grid boundary.

DFS Traversal

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

Start DFS from any land cell and explore the entire island. During traversal, count edges that face water or grid boundaries. This approach naturally handles the connected component.

Smart Edge Counting

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

Start by counting 4 edges for every land cell. Then subtract 2 edges for each pair of adjacent land cells (since they share a border). This eliminates the need to check boundaries explicitly.

Count All Edges — Algorithm Steps

Step 1: Iterate through each cell in the grid
Step 2: For each land cell (value = 1), check all 4 adjacent positions
Step 3: Count edges where adjacent cell is water (0) or out of bounds
Step 4: Return total count of perimeter edges

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Land Cell

Locate a cell with value 1

Check 4 Directions

Count edges facing water/boundary

Sum All Edges

Total perimeter count

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int maxSize = 0;

bool isValidBST(struct TreeNode* node, long long minVal, long long maxVal) {
    if (!node) return true;
    if (node->val <= minVal || node->val >= maxVal) return false;
    return isValidBST(node->left, minVal, node->val) && 
           isValidBST(node->right, node->val, maxVal);
}

int countNodes(struct TreeNode* node) {
    if (!node) return 0;
    return 1 + countNodes(node->left) + countNodes(node->right);
}

void traverse(struct TreeNode* node) {
    if (!node) return;
    
    if (isValidBST(node, LLONG_MIN, LLONG_MAX)) {
        int size = countNodes(node);
        if (size > maxSize) maxSize = size;
    }
    
    traverse(node->left);
    traverse(node->right);
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    maxSize = 0;
    traverse(root);
    return maxSize;
}

struct TreeNode* buildTree(char* input) {
    if (strcmp(input, "[]") == 0) return NULL;
    
    // Remove brackets
    input++;
    input[strlen(input)-1] = '\0';
    
    char* token = strtok(input, ",");
    if (!token) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && (token = strtok(NULL, ",")) != NULL) {
        struct TreeNode* node = queue[front++];
        
        if (strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = '\0';
    
    struct TreeNode* root = buildTree(input);
    printf("%d\n", solution(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit every cell in the m×n grid once

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra variables

✓ Linear Space

285.0K Views

Medium Frequency

~15 min Avg. Time

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

Count All Edges — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler