909. Android解锁模式

909. Android解锁模式

 

 

给定一个Android  3x3 锁定屏幕和两个整数 m 和 n ,其中 1≤m≤n≤9 ,统计可以解锁Android锁定屏幕所有有效模式的总数,包括最少的 m 个键和最多 n 个键。

有效模式的规则:

每个模式必须连接至少 m 个键和最多 n 个键。

所有的键都必须是不同的。

如果在模式中连接两个连续键的行通过任何其他键，则其他键必须在模式中选择。不允许跳过非选择键。

钥匙的顺序很重要。

 

解释：

| 1 | 2 | 3 |

| 4 | 5 | 6 |

| 7 | 8 | 9 |

 

无效移动:  4 - 1 - 3 - 6

路径1 - 3通过在模式中没有选择的关键2.

无效移动:  4 - 1 - 9 - 2

路径1 - 9通过在模式中没有选择的关键9

有效移动:  2 - 4 - 1 - 3 - 6

路径1 - 3是有效的，因为它通过了模式中选择的关键2。

路径1 - 9通过在模式中没有选择的关键9

有效移动:  6 - 5 - 4 - 1 - 9 - 2

路径1 - 9是有效的，因为它通过了模式中选择的关键5。

样例

样例1

输入: m = 1, n = 1

输出: 9

样例2

输入: m = 1, n = 2

输出: 65

 

 

 

public class Solution {

    /**

     * @param m: an integer

     * @param n: an integer

     * @return: the total number of unlock patterns of the Android lock screen

     */

    public int numberOfPatterns(int m, int n) {

        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] = 5;

        skip[2][8] = skip[8][2] = 5;

        skip[3][7] = skip[7][3] = 5;

        skip[4][6] = skip[6][4] = 5;

 

 

        int rst = 0;

        ArrayList<Integer> visited = new ArrayList<>();//记录走过的位置

        for (int i = m - 1; i < n; i++) {

            rst += dfs(visited, skip, 1, i) * 4; //1, 3, 7, 9

            rst += dfs(visited, skip, 2, i) * 4; //2, 4, 6, 9

            rst += dfs(visited, skip, 5, i);//5

        }

        return rst;

    }

 

 

    /**

     *

     * @param visited 走过的点

     * @param skip  里面是走法规则

     * @param cur   要走的点

     * @param remlen 剩余可以走的步数

     * @return

     */

    private int dfs(ArrayList<Integer> visited, int[][] skip, int cur, int remlen) {

        if (remlen == 0) {//当前长度只有一，那么结果只有一种

            return 1;

        }

        visited.add(cur);

        int cnt = 0;

        for (int i = 1; i < 10; i++) {

            if (!visited.contains(i)) {

                if (skip[cur][i] == 0 || visited.contains(skip[cur][i])) {

                    cnt += dfs(visited, skip, i, remlen - 1);

                }

            }

        }

        visited.remove(visited.indexOf(cur));

        return cnt;

    }

}