[LeetCode] 351. Android Unlock Patterns 安卓解锁模式
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,5是单独的一个,所以总共求3组就可以了。
解法:DFS,建立一个二维数组jumps,用来记录两个数字键之间是否有中间键,然后再用一个一位数组visited来记录某个键是否被访问过,然后用递归来解,先对1调用递归函数,在递归函数中遍历1到9每个数字next,然后找他们之间是否有jump数字,如果next没被访问过,并且jump为0,或者jump被访问过,对next调用递归函数。数字1的模式个数算出来后,由于1,3,7,9是对称的,所以我们乘4即可,然后再对数字2调用递归函数,2,4,6,9也是对称的,再乘4,最后单独对5调用一次,然后把所有的加起来就是最终结果。参考
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];
if (i<=3 && i+6==j) return keypad[i+3] && !keypad[to];
return !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++) {
if (valid(keypad, from, i)) {
keypad[i] = true;
find(keypad, i, step+1, m, n);
keypad[i] = false;
}
}
}
public int numberOfPatterns(int m, int n) {
boolean[] keypad = new boolean[10];
for(int i=1; i<=9; i++) {
keypad[i] = true;
find(keypad, i, 1, m, n);
keypad[i] = false;
}
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;
}
};
All LeetCode Questions List 题目汇总
[LeetCode] 351. Android Unlock Patterns 安卓解锁模式的更多相关文章
- [LeetCode] Android Unlock Patterns 安卓解锁模式
Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total ...
- LC 351. Android Unlock Patterns
Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total ...
- 351. Android Unlock Patterns
这个题我真是做得想打人了卧槽. 题目不难,就是算组合,但是因为是3乘3的键盘,所以只需要从1和2分别开始DFS,结果乘以4,再加上5开始的DFS就行了. 问题是这个傻逼题目的设定是,从1到8不需要经过 ...
- [Swift]LeetCode351. 安卓解锁模式 $ Android Unlock Patterns
Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total ...
- Leetcode: Android Unlock Patterns
Given an Android 3x3 key ≤ m ≤ n ≤ , count the total number of unlock patterns of the Android lock s ...
- Android Unlock Patterns
Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total ...
- 白底黑字!Android浅色状态栏黑色字体模式(另)
小彬什么都想做任重致远 关注 2016.06.30 10:16* 字数 489 阅读 3234评论 3喜欢 12 前言 由于该死不死的设计湿,设计了一套白色状态栏的UI.当然在iOS上可以实现自适应, ...
- Eclipse+ADT+Android SDK 搭建安卓开发环境
Eclipse+ADT+Android SDK 搭建安卓开发环境 要求 必备知识 windows 7 基本操作. 运行环境 windows 7(64位); eclipse-jee-luna-SR2 ...
- Android中的创建型模式总结
共5种,单例模式.工厂方法模式.抽象工厂模式.建造者模式.原型模式 单例模式 定义:确保某一个类的实例只有一个,而且向其他类提供这个实例. 单例模式的使用场景:某个类的创建需要消耗大量资源,new一个 ...
随机推荐
- PAT甲级1010踩坑记录(二分查找)——10测试点未过待更新
题目分析: 首先这题有很多的坑点,我在写完之后依旧还有第10个测试点没有通过,而且代码写的不优美比较冗长勿喷,本篇博客用于记录写这道题的一些注意点 1.关于两个不同进制的数比大小一般采用将两个数都转化 ...
- 玩转DNS服务器——Bind服务
合理的配置DNS的查询方式 实验环境: 虚拟机:VMware® Workstation 15 Pro 均使用NAT连接 网段为192.168.1.0/24 DNS 服务器 ---- Centos ...
- myeclipse常用快捷(持续更新)
最近开始转用myeclipse,总结一下快捷方式:(我喜欢用的) [Ctrl+O] 显示类中方法和属性的大纲,能快速定位类的方法和属性,在查找Bug时非常有用. [Ctrl+M] 窗口最大 ...
- py3+requests+json+xlwt,爬取拉勾招聘信息
在拉勾搜索职位时,通过谷歌F12抓取请求信息 发现请求是一个post请求,参数为: 返回的是json数据 有了上面的基础,我们就可以构造请求了 然后对获取到的响应反序列化,这样就获取到了json格式的 ...
- Browsersync 省时浏览器同步测试工具,浏览器自动刷新,多终端同步
官网地址 http://www.browsersync.cn/ 1.安装 BrowserSync npm install -g browser-sync 2.启动 BrowserSync // --f ...
- maven 使用dependencyManagement统一管理依赖版本
今日思语:人生方方长长,努力把她磨成方圆,所以 加油咯~ 使用maven可以很方便的进行项目依赖的管理,即可以管理我们显示引入具体版本的依赖,也可以管理某些第三方引入的一些依赖的版本,从而能更好的实现 ...
- 关于吲哚美辛(NSAIDS)对袢利尿药的影响。
吲哚美辛 一方面是解热镇痛抗炎药,是最强的PG合成酶抑制药之一,另一方面,吲哚美辛可于袢利尿药如呋塞米.依他尼酸竞争近曲小管有机酸分泌途径,可以影响后者的排泄和作用. 吲哚美辛可以抑制前列腺素的合成, ...
- 学习Spring-Data-Jpa(十)---注解式方法查询之@Query、@Modifying与派生delete
1.@Query 对于少量的查询,使用@NamedQuery在实体上声明查询是一种有效的办法,并且可以很好的工作.由于查询本身绑定到执行它们的java方法,实际上可以通过Spring-Data-Jpa ...
- OLED液晶屏幕(0)自动获取12ic地址液晶屏幕
. 烧录 串口可以看到输出的地址 #include <Wire.h> void setup(){ Wire.begin(); Serial.begin(9600); Serial.prin ...
- 第三章 - SQL基础及元数据获取
SQL的介绍 SQL的定义:结构化查询语句 SQL的作用:对库和表进行操作 SQL的常用分类 DDL 数据定义语言(Data Definition Language) DCL 数据控制语言(Data ...