Codestin Search App

Android Unlock Patterns - Problem

Android devices feature a unique security system: a 3x3 grid of dots that users connect to create unlock patterns. Imagine drawing lines between numbered dots (1-9) where each line segment connects two consecutive dots in your sequence.

The challenge? Not all connections are valid! Here are the rules:

All dots must be unique - you can't use the same dot twice
No jumping through unvisited dots - if your line passes through the center of another dot, that dot must have been visited earlier

For example:

1 2 3
4 5 6
7 8 9

❌ Invalid: [4,1,3,6] - connecting 1→3 passes through dot 2, but 2 wasn't visited first
✅ Valid: [2,4,1,3,6] - now 1→3 is allowed because 2 was visited earlier

Your mission: Given integers m and n, count all unique valid unlock patterns with length between m and n dots (inclusive).

Input & Output

example_1.py — Basic Range

$ Input: m = 1, n = 1

› Output: 9

💡 Note: All single-dot patterns are valid: [1], [2], [3], [4], [5], [6], [7], [8], [9]. Each dot can be a valid pattern of length 1.

example_2.py — Small Range

$ Input: m = 1, n = 2

› Output: 65

💡 Note: Includes all 9 single-dot patterns plus all valid 2-dot patterns. From each dot, you can move to any other dot except those that require jumping through unvisited intermediate dots.

example_3.py — Edge Case

$ Input: m = 3, n = 3

› Output: 320

💡 Note: Only counts patterns of exactly length 3. Many more possibilities exist since by length 3, intermediate dots for jumps are more likely to have been visited.

Constraints

1 ≤ m ≤ n ≤ 9
Grid is always 3×3 with dots numbered 1-9
Jump Rule: Cannot connect two dots if line passes through center of unvisited dot

Visualization

Tap to expand

Understanding the Visualization

Setup Grid

Create 3×3 grid with numbered dots 1-9, establishing jump rules for invalid moves

Identify Symmetries

Recognize that corners, edges, and center have equivalent movement patterns due to rotational symmetry

Compute Representatives

Calculate all valid patterns starting from one corner (1), one edge (2), and center (5)

Apply Multipliers

Multiply by symmetry factors: corner patterns×4 + edge patterns×4 + center patterns×1

Key Takeaway

🎯 Key Insight: Exploit rotational symmetry of the 3×3 grid to reduce computation from 9 to 3 representative DFS calculations, achieving a 4x performance improvement while maintaining perfect accuracy.

Asked in

G Google 45 a Amazon 32 f Meta 28 Apple 25

The optimal approach uses symmetry optimization to reduce computation by 4x. Instead of computing DFS for all 9 starting positions, we recognize that corners (1,3,7,9) have identical patterns, edges (2,4,6,8) share patterns, and center (5) is unique. We calculate patterns for one representative from each group and multiply by occurrence counts: corner×4 + edge×4 + center×1.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS with Validation	O(9!)	O(9)	Generate all possible paths using DFS and validate jump rules for each path
Optimized DFS with Symmetry (Optimal)	O(9!/4)	O(9)	Exploit grid symmetry to reduce computation by 4x using pattern equivalence

Brute Force DFS with Validation — Algorithm Steps

Create a jump table mapping which dot blocks each pair of dots
For each starting position (1-9), begin DFS traversal
At each step, try moving to every unvisited dot (1-9)
Check if the move is valid (no blocked intermediate dot)
If valid, mark dot as visited and continue DFS
Count valid paths when length is between m and n
Backtrack by unmarking the dot and trying next option

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Grid

Set up 3x3 grid with dots 1-9 and create jump validation rules

Start DFS from Each Dot

Begin depth-first search from every possible starting position (1-9)

Explore All Paths

For each position, try moving to every unvisited dot, validating jump rules

Count Valid Patterns

Accumulate count when path length falls within [m,n] range

Code -

solution.c — C

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

int jumps[10][10];
bool visited[10];

int dfs(int current, int length, int m, int n) {
    if (length > n) return 0;
    
    int count = length >= m ? 1 : 0;
    
    for (int next = 1; next <= 9; next++) {
        if (visited[next]) continue;
        
        if (jumps[current][next] != 0 && !visited[jumps[current][next]]) {
            continue;
        }
        
        visited[next] = true;
        count += dfs(next, length + 1, m, n);
        visited[next] = false;
    }
    
    return count;
}

int numberOfPatterns(int m, int n) {
    memset(jumps, 0, sizeof(jumps));
    jumps[1][3] = jumps[3][1] = 2;
    jumps[4][6] = jumps[6][4] = 5;
    jumps[7][9] = jumps[9][7] = 8;
    jumps[1][7] = jumps[7][1] = 4;
    jumps[2][8] = jumps[8][2] = 5;
    jumps[3][9] = jumps[9][3] = 6;
    jumps[1][9] = jumps[9][1] = 5;
    jumps[3][7] = jumps[7][3] = 5;
    
    int total = 0;
    memset(visited, false, sizeof(visited));
    
    for (int start = 1; start <= 9; start++) {
        visited[start] = true;
        total += dfs(start, 1, m, n);
        visited[start] = false;
    }
    
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(9!)

In worst case, we explore all permutations of 9 dots, leading to factorial time complexity

✓ Linear Growth

Space Complexity

O(9)

Recursion stack depth is at most 9 (visiting all dots), plus visited array of size 9

✓ Linear Space

52.4K Views

Medium Frequency

~25 min Avg. Time

1.8K 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 with Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler