Topcoder_2_157

【问题描述】
    数组a[1], a[2], ... a[k*n]是一个k阶的循环数组，即数组的数字是1至n，循环k次。在该数组中如果任意紧邻的2个元素不相同，就定义其为“不友好的”，例如2阶数组 (1, 2, 3, 2, 1, 3)就是“不友好的”，但是(1, 2, 2, 3, 1, 3)不是。
    题目中给定n和k，需要求出k阶n维数组中所有“不友好的”数组的个数。

  定义：
类  UnfriendlyMultiPermutation
方法  public int count(int n, int k)

  约束：
1、n取值范围为1至20；
2、k取值范围为1至5。

  测试用例：
1、2    2    Returns: 2
2、3    2    Returns: 30
3、5    1    Returns: 120
4、2    4    Returns: 2

1. public class UnfriendlyMultiPermutation {
2.     /**
3.      * 使用递归的方式对数组进行排列，剔除掉不符合要求的排列得到符合要求的数量。
4.      * 然后再删除重复的排列，方法就是除以重复的次数得到就是所有不重复的数量。
5.      * 例如：对于n=2,k=4
6.      * 合法的排列是"1 2 1 2 1 2 1 2"和"2 1 2 1 2 1 2 1"，对于第一个串因为第1、3、5、7位置上
7.      * 的1会造成结果的重复（2同样有此问题），所以应该除以4!×4!（4!=4×3×2×1）来剔除掉重复的数量。
8.      */
9.     private int[] numArray;
10.     private int count = 0;
12.     public int count(int n, int k) {
13.         numArray = new int[k * n];
14.         int[] flag = new int[k * n];
15.         for (int i = 0; i < n; i++)
16.             for (int x = 0; x < k; x++)
17.                 numArray[i * k + x] = i + 1;
18.         
19.         calCount(flag, 0);
20.         int fun = 1;
21.         for (int i = 2; i <= k; i++){
22.             fun *= i;
23.         }
24.         return count / ((int) Math.pow(fun, n));
25.     }
27.     private void calCount(int[] flag, int lastNum) {
28.         boolean isOver = true;
29.         for (int i = 0; i < flag.length; i++) {
30.             if (flag[i] == 0) {
31.                 flag[i] = 1;
32.                 isOver = false;
33.                 if (lastNum != numArray[i]) {
34.                     calCount(flag, numArray[i]);
35.                 }
36.                 flag[i] = 0;
37.             }
38.         }
39.         if (isOver) {
40.             count++;
41.         }
42.     }
43. }