2、骑士拨号器（Weekly Contest 109）

题目描述

这道题还是有点点难度的，因为要使用动态规划的知识，首先如果N=1，那么跳0次组成的就是10种，如果跳1次即N=2，那么就是这样的等于最后跳在1的个数和2的个数。。。到0的个数之和，如果跳2次即N=3，那么就是从1跳的个数加上1能跳到那个数字之和，可能有点说不清直接看代码即可，每次起跳都用到了之前的dp数组，即下一次跳组成的个数等于的是当前的起跳个数加上上一次起跳的和，还需要注意的是由于次数太大，需要定义一个数字作为模
代码

class Solution {
    public int knightDialer(int N) {
        if(N == 1){
			return 10;
		}
		//首先初始化跳的棋子，用一个二维数组来表示，横坐标表示的是起跳的位置，其对应的是跳的位置，比如：
		//1跳的位置是6和8，5没有落子位置，2对应的是7和9
		int [][]nums = {
				{4,6},
				{6,8},
				{7,9},
				{4,8},
				{3,9,0},
				{},
				{1,7,0},
				{2,6},
				{1,3},
				{2,4}
		};
		//dp数组定义的意义是初始化一下，初始值表示的是N=1 表示跳0步，从0-9都是1，即初始为1
		int x = 1000000000 + 7;
		int dp[] = {1,1,1,1,1,1,1,1,1,1};
		//循环次数为N-1
		while (N-- > 1) {
			int []tem = new int[10];
			for (int i = 0; i < 10; i++) {
				//从起跳点是0开始进行，比如：0跳一次可以跳到4和6，那么tem数组的4和6下标就加上1
				for (int j = 0; j < nums[i].length; j++) {
					//注意的是tem数组的下标表示循环到当前次数时跳到当前位置的总的个数
					tem[nums[i][j]] = (tem[nums[i][j]] % x + dp[i] % x);
				}
			}
			//更新dp数组
			dp = tem.clone();
			//System.out.println(Arrays.toString(dp));
		}
		int sum = 0;
		for (int i = 0; i < dp.length; i++) {
			sum = (sum + dp[i] % x) % x;
		}
		return sum;
        
    }
}

排名靠前的代码，好像没用动态规划，有点厉害

class Solution {
    public int knightDialer(int N) {
        if(N==0) return 0;
        if(N==1) return 10;

        int mod = 1000000007;
        long a = 1; // 0
        long b = 4; // 1,3,7,9
        long c = 2; // 2,8
        long d = 2; // 4,6

        for (int i = 1; i <N ; i++) {
            long next_a = d;
            long next_b = (c+d) * 2; //(2,6),(2,4),(6,8),(4,8)
            long next_c = b;
            long next_d = a*2+b;//(0,3,9),(0,1,7)

            a = next_a % mod;
            b = next_b % mod;
            c = next_c % mod;
            d = next_d % mod;

        }

        return (int)((a+b+c+d)%mod);

    }
}