Android Unlock Patterns

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

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

✓ Brute Force DFS with Validation

⏱️ Time: O(9!) Space: O(9)

This approach uses depth-first search to explore all possible paths from each starting dot. For every path, we validate that jumps over intermediate dots are legal (the intermediate dot was visited earlier). We track visited dots using a boolean array and recursively build paths of all lengths from m to n.

Optimized DFS with Symmetry (Optimal)

⏱️ Time: O(9!/4) Space: O(9)

This optimized approach recognizes that the 3x3 grid has rotational symmetry. Corner dots (1,3,7,9) all have identical movement patterns, and edge dots (2,4,6,8) share the same constraints. Instead of computing DFS for all 9 starting positions, we compute it for one corner, one edge, and the center, then multiply by their occurrence counts.

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 <stdlib.h>
#include <string.h>

int solution(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    int maxMatched = 0;
    
    // Try starting from each position in s
    for (int start = 0; start < sLen; start++) {
        int i = start;
        int j = 0;
        
        // Use two pointers to find longest match starting from position 'start'
        while (i < sLen && j < tLen) {
            if (s[i] == t[j]) {
                j++;
            }
            i++;
        }
        
        // Update maximum matched characters
        if (j > maxMatched) {
            maxMatched = j;
        }
        
        // Early termination if we matched everything
        if (maxMatched == tLen) {
            break;
        }
    }
    
    return tLen - maxMatched;
}

int main() {
    char s[1000], t[1000];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    int result = solution(s, t);
    printf("%d\n", result);
    
    return 0;
}

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