# [LeetCode] 351. Android Unlock Patterns 安卓解锁模式

2021年09月15日 阅读数：1

Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total number of unlock patterns of the Android lock screen, which consist of minimum of m keys and maximum n keys.html

Rules for a valid pattern:java

1. Each pattern must connect at least m keys and at most n keys.
2. All the keys must be distinct.
3. If the line connecting two consecutive keys in the pattern passes through any other keys, the other keys must have previously selected in the pattern. No jumps through non selected key is allowed.
4. The order of keys used matters.

Explanation:python

```| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |```

Invalid move: `4 - 1 - 3 - 6 `
Line 1 - 3 passes through key 2 which had not been selected in the pattern.android

Invalid move: `4 - 1 - 9 - 2`
Line 1 - 9 passes through key 5 which had not been selected in the pattern.git

Valid move: `2 - 4 - 1 - 3 - 6`
Line 1 - 3 is valid because it passes through key 2, which had been selected in the pattern数组

Valid move: `6 - 5 - 4 - 1 - 9 - 2`
Line 1 - 9 is valid because it passes through key 5, which had been selected in the pattern.函数

Example:
Given m = 1, n = 1, return 9.post

Java:

```public class Solution {
private int patterns;
private boolean valid(boolean[] keypad, int from, int to) {
if (from==to) return false;
int i=Math.min(from, to), j=Math.max(from,to);
if ((i==1 && j==9) || (i==3 && j==7)) return keypad[5] && !keypad[to];
if ((i==1 || i==4 || i==7) && i+2==j) return keypad[i+1] && !keypad[to];
}
private void find(boolean[] keypad, int from, int step, int m, int n) {
if (step == n) {
patterns ++;
return;
}
if (step >= m) patterns ++;
for(int i=1; i<=9; i++) {
}
}
}
public int numberOfPatterns(int m, int n) {
for(int i=1; i<=9; i++) {
}
return patterns;
}
}```

Java:

```public class Solution {
// cur: the current position
// remain: the steps remaining
int DFS(boolean vis[], int[][] skip, int cur, int remain) {
if(remain < 0) return 0;
if(remain == 0) return 1;
vis[cur] = true;
int rst = 0;
for(int i = 1; i <= 9; ++i) {
// If vis[i] is not visited and (two numbers are adjacent or skip number is already visited)
if(!vis[i] && (skip[cur][i] == 0 || (vis[skip[cur][i]]))) {
rst += DFS(vis, skip, i, remain - 1);
}
}
vis[cur] = false;
return rst;
}

public int numberOfPatterns(int m, int n) {
// Skip array represents number to skip between two pairs
int skip[][] = new int[10][10];
skip[1][3] = skip[3][1] = 2;
skip[1][7] = skip[7][1] = 4;
skip[3][9] = skip[9][3] = 6;
skip[7][9] = skip[9][7] = 8;
skip[1][9] = skip[9][1] = skip[2][8] = skip[8][2] = skip[3][7] = skip[7][3] = skip[4][6] = skip[6][4] = 5;
boolean vis[] = new boolean[10];
int rst = 0;
// DFS search each length from m to n
for(int i = m; i <= n; ++i) {
rst += DFS(vis, skip, 1, i - 1) * 4;    // 1, 3, 7, 9 are symmetric
rst += DFS(vis, skip, 2, i - 1) * 4;    // 2, 4, 6, 8 are symmetric
rst += DFS(vis, skip, 5, i - 1);        // 5
}
return rst;
}
}　　```

Python:

```# Time:  O(9!)
# Space: O(9)
# Backtracking solution. (TLE)
class Solution_TLE(object):
def numberOfPatterns(self, m, n):
"""
:type m: int
:type n: int
:rtype: int
"""
def merge(used, i):
return used | (1 << i)

def contain(used, i):
return bool(used & (1 << i))

def convert(i, j):
return 3 * i + j

def numberOfPatternsHelper(m, n, level, used, i):
number = 0
if level > n:
return number

if m <= level <= n:
number += 1

x1, y1 = divmod(i, 3)
for j in xrange(9):
if contain(used, j):
continue

x2, y2 = divmod(j, 3)
if ((x1 == x2 and abs(y1 - y2) == 2) or
(y1 == y2 and abs(x1 - x2) == 2) or
(abs(x1 - x2) == 2 and abs(y1 - y2) == 2)) and \
not contain(used,
convert((x1 + x2) // 2, (y1 + y2) // 2)):
continue

number += numberOfPatternsHelper(m, n, level + 1, merge(used, j), j)

return number

number = 0
# 1, 3, 7, 9
number += 4 * numberOfPatternsHelper(m, n, 1, merge(0, 0), 0)
# 2, 4, 6, 8
number += 4 * numberOfPatternsHelper(m, n, 1, merge(0, 1), 1)
# 5
number += numberOfPatternsHelper(m, n, 1, merge(0, 4), 4)
return number
```

Python:

```# Time:  O(9^2 * 2^9)
# Space: O(9 * 2^9)
# DP solution.
class Solution2(object):
def numberOfPatterns(self, m, n):
"""
:type m: int
:type n: int
:rtype: int
"""
def merge(used, i):
return used | (1 << i)

def number_of_keys(i):
number = 0
while i > 0:
i &= i - 1
number += 1
return number

def exclude(used, i):
return used & ~(1 << i)

def contain(used, i):
return bool(used & (1 << i))

def convert(i, j):
return 3 * i + j

# dp[i][j]: i is the set of the numbers in binary representation,
#            d[i][j] is the number of ways ending with the number j.
dp = [[0] * 9 for _ in xrange(1 << 9)]
for i in xrange(9):
dp[merge(0, i)][i] = 1

res = 0
for used in xrange(len(dp)):
number = number_of_keys(used)
if number > n:
continue

for i in xrange(9):
if not contain(used, i):
continue

x1, y1 = divmod(i, 3)
for j in xrange(9):
if i == j or not contain(used, j):
continue

x2, y2 = divmod(j, 3)
if ((x1 == x2 and abs(y1 - y2) == 2) or
(y1 == y2 and abs(x1 - x2) == 2) or
(abs(x1 - x2) == 2 and abs(y1 - y2) == 2)) and \
not contain(used,
convert((x1 + x2) // 2, (y1 + y2) // 2)):
continue

dp[used][i] += dp[exclude(used, i)][j]

if m <= number <= n:
res += dp[used][i]

return res
```

Python:

```# DP solution.
class Solution(object):
def numberOfPatterns(self, m, n):
"""
:type m: int
:type n: int
:rtype: int
"""
def merge(used, i):
return used | (1 << i)

def number_of_keys(i):
number = 0
while i > 0:
i &= i - 1
number += 1
return number

def contain(used, i):
return bool(used & (1 << i))

def convert(i, j):
return 3 * i + j

# dp[i][j]: i is the set of the numbers in binary representation,
#           dp[i][j] is the number of ways ending with the number j.
dp = [[0] * 9 for _ in xrange(1 << 9)]
for i in xrange(9):
dp[merge(0, i)][i] = 1

res = 0
for used in xrange(len(dp)):
number = number_of_keys(used)
if number > n:
continue

for i in xrange(9):
if not contain(used, i):
continue

if m <= number <= n:
res += dp[used][i]

x1, y1 = divmod(i, 3)
for j in xrange(9):
if contain(used, j):
continue

x2, y2 = divmod(j, 3)
if ((x1 == x2 and abs(y1 - y2) == 2) or
(y1 == y2 and abs(x1 - x2) == 2) or
(abs(x1 - x2) == 2 and abs(y1 - y2) == 2)) and \
not contain(used,
convert((x1 + x2) // 2, (y1 + y2) // 2)):
continue

dp[merge(used, j)][j] += dp[used][i]

return res
```

C++:

```// DP solution.
class Solution {
public:
int numberOfPatterns(int m, int n) {
// dp[i][j]: i is the set of the numbers in binary representation,
//           dp[i][j] is the number of ways ending with the number j.
vector<vector<int>> dp(1 << 9 , vector<int>(9, 0));
for (int i = 0; i < 9; ++i) {
dp[merge(0, i)][i] = 1;
}

int res = 0;
for (int used = 0; used < dp.size(); ++used) {
const auto number = number_of_keys(used);
if (number > n) {
continue;
}
for (int i = 0; i < 9; ++i) {
if (!contain(used, i)) {
continue;
}
if (m <= number && number <= n) {
res += dp[used][i];
}

const auto x1 = i / 3;
const auto y1 = i % 3;
for (int j = 0; j < 9; ++j) {
if (contain(used, j)) {
continue;
}
const auto x2 = j / 3;
const auto y2 = j % 3;
if (((x1 == x2 && abs(y1 - y2) == 2) ||
(y1 == y2 && abs(x1 - x2) == 2) ||
(abs(x1 - x2) == 2 && abs(y1 - y2) == 2)) &&
!contain(used, convert((x1 + x2) / 2, (y1 + y2) / 2))) {
continue;
}
dp[merge(used, j)][j] += dp[used][i];
}
}
}

return res;
}

private:
inline int merge(int i, int j) {
return i | (1 << j);
}

inline int number_of_keys(int i) {
int number = 0;
for (; i; i &= i - 1) {
++number;
}
return number;
}

inline bool contain(int i, int j) {
return i & (1 << j);
}

inline int convert(int i, int j) {
return 3 * i + j;
}
};
```

C++:

```// Time:  O(9^2 * 2^9)
// Space: O(9 * 2^9)
// DP solution.
class Solution2 {
public:
int numberOfPatterns(int m, int n) {
// dp[i][j]: i is the set of the numbers in binary representation,
//           dp[i][j] is the number of ways ending with the number j.
vector<vector<int>> dp(1 << 9 , vector<int>(9, 0));
for (int i = 0; i < 9; ++i) {
dp[merge(0, i)][i] = 1;
}

int res = 0;
for (int used = 0; used < dp.size(); ++used) {
const auto number = number_of_keys(used);
if (number > n) {
continue;
}
for (int i = 0; i < 9; ++i) {
if (!contain(used, i)) {
continue;
}

const auto x1 = i / 3;
const auto y1 = i % 3;
for (int j = 0; j < 9; ++j) {
if (i == j || !contain(used, j)) {
continue;
}
const auto x2 = j / 3;
const auto y2 = j % 3;
if (((x1 == x2 && abs(y1 - y2) == 2) ||
(y1 == y2 && abs(x1 - x2) == 2) ||
(abs(x1 - x2) == 2 && abs(y1 - y2) == 2)) &&
!contain(used, convert((x1 + x2) / 2, (y1 + y2) / 2))) {
continue;
}
dp[used][i] += dp[exclude(used, i)][j];
}
if (m <= number && number <= n) {
res += dp[used][i];
}
}
}

return res;
}

private:
inline int merge(int i, int j) {
return i | (1 << j);
}

inline int number_of_keys(int i) {
int number = 0;
for (; i; i &= i - 1) {
++number;
}
return number;
}

inline bool contain(int i, int j) {
return i & (1 << j);
}

inline int exclude(int i, int j) {
return i & ~(1 << j);
}

inline int convert(int i, int j) {
return 3 * i + j;
}
};
```

C++:

```// Time:  O(9!)
// Space: O(9)
// Backtracking solution.
class Solution3 {
public:
int numberOfPatterns(int m, int n) {
int number = 0;
// 1, 3, 5, 7
number += 4 * numberOfPatternsHelper(m, n, 1, merge(0, 0), 0);
// 2, 4, 6, 8
number += 4 * numberOfPatternsHelper(m, n, 1, merge(0, 1), 1);
// 5
number += numberOfPatternsHelper(m, n, 1, merge(0, 4), 4);
return number;
}

private:
int numberOfPatternsHelper(int m, int n, int level, int used, int i) {
int number = 0;
if (level > n) {
return number;
}
if (level >= m) {
++number;
}

const auto x1 = i / 3;
const auto y1 = i % 3;
for (int j = 0; j < 9; ++j) {
if (contain(used, j)) {
continue;
}
const auto x2 = j / 3;
const auto y2 = j % 3;
if (((x1 == x2 && abs(y1 - y2) == 2) ||
(y1 == y2 && abs(x1 - x2) == 2) ||
(abs(x1 - x2) == 2 && abs(y1 - y2) == 2)) &&
!contain(used, convert((x1 + x2) / 2, (y1 + y2) / 2))) {
continue;
}
number += numberOfPatternsHelper(m, n, level + 1, merge(used, j), j);
}

return number;
}

private:
inline int merge(int i, int j) {
return i | (1 << j);
}

inline bool contain(int i, int j) {
return i & (1 << j);
}

inline int convert(int i, int j) {
return 3 * i + j;
}
};
```

C++:

```class Solution {
public:
int DFS(int m, int n, int len, int num)
{
int cnt = 0;
if(len >= m) cnt++;
if(++len > n) return cnt;
visited[num] = true;
for(int i = 1; i<= 9; i++)
if(!visited[i] && visited[hash[num][i]])
cnt += DFS(m, n, len, i);
visited[num] = false;
return cnt;
}

int numberOfPatterns(int m, int n) {
if(m < 1 || n < 1) return 0;
visited.resize(10, false);
visited[0] = true;
hash.resize(10, vector<int>(10, 0));
hash[1][3] = hash[3][1] = 2;
hash[1][7] = hash[7][1] = 4;
hash[3][9] = hash[9][3] = 6;
hash[7][9] = hash[9][7] = 8;
hash[2][8] = hash[8][2] = hash[4][6] = hash[6][4] = 5;
hash[1][9] = hash[9][1] = hash[3][7] = hash[7][3] = 5;
return DFS(m, n, 1, 1)*4 + DFS(m, n, 1, 2)*4 + DFS(m, n, 1, 5);
}
private:
vector<bool> visited;
vector<vector<int>> hash;
};
```

C++:

```class Solution {
public:
int numberOfPatterns(int m, int n) {
return count(m, n, 0, 1, 1);
}
int count(int m, int n, int used, int i1, int j1) {
if (n == 0) return 1;
int res = (m <= 0);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
// used2 check middle point has been used
int I = i1+i, J = j1+j, used2 = used | (1 << (i*3+j));
// used2 > used: add a new unused integer
// I%2 == 1: i1 odd i even or reverse
// used2 & (1 << I/2*3+J/2): mid point has been used
if (used2 > used && (I%2 || J%2 || used2 & (1 << I/2*3+J/2))) {
res += count(m-1, n-1, used2, i, j);
}
}
}
return res;
}
};
```