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.
Rules for a valid pattern:
- Each pattern must connect at least m keys and at most n keys.
- All the keys must be distinct.
- 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.
- The order of keys used matters.
Explanation:
| 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.
Invalid move: 4 - 1 - 9 - 2
Line 1 - 9 passes through key 5 which had not been selected in the pattern.
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.
在安卓的3*3的解锁屏幕上，给出2个整数m, n(1 ≤ m ≤ n ≤ 9)，问在m到n的滑动次数之间，有多少种可能的解锁方案。给出了合理和不合理的滑动。
优化方法是，由于 1,3,7,9 是对称的，2,4,6,8也是对称的，所以只用计算其中一个，然后乘以4就可以了。
解法：DFS
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;
}
};
All LeetCode Questions List 题目汇总