Topcoder_3_159

【问题描述】
    有一种步长基于2的幂次的图bishop，目的是从原点(0, 0)到目的点(finishX, finishY)。如果从(x, y)移动那么所到达的下一个点会有4种可能，分别是：(x + 2^k, y + 2^k)、(x + 2^k, y - 2^k)、(x - 2^k, y + 2^k)、(x - 2^k, y - 2^k)，k是非负整数（0或者正整数）。唯一的限制就是所有步骤k取值必须不同。
    需要返回一个字符串数组表示从 (0, 0) 到 (finishX, finishY) 所有经历的路径，包括开始点和结束点。每个数组的元素描述所经过点的x,y坐标按照"x, y"的形式表示。如果结果有多种走法，那么返回路径最短和字母顺序在前的走法（顺序为',', '-', '0', '1', ..., '9'）。如果不能到达目的那么返回一个空字符串数组。
    注：如果走法有A和B两个字符串数组，按照数组index顺序比较两者对应的字符串，假如A较小则结果返回数组A。finishX，finishY取值范围在1至100000000。

  定义：
类  BinaryPowerBishop
方法  public String[] getPath(int finishX, int finishY)

  测试用例：
1、16  16
Returns: {"0,0", "16,16" }
2、8   24
Returns: {"0,0", "-8,8", "8,24" }
3、11   22
Returns: { }
注：按照走法从点(x1, y1)到点(x2, y2)，x1+y1和x2+y2的奇偶性应是相同的，因此对于x, y坐标和为奇数的点是不可到达的。
4、123   321
Returns: {"0,0", "-128,128", "-112,112", "-104,104", "-100,100", "-102,98", "-101,97", "-133,65", "123,321" }

1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.List;
4. import java.util.Stack;
6. public class BinaryPowerBishop {
7.     private int[] binary = new int[28];
8.     private int[] flag = new int[binary.length];
9.     private Stack<String> resStr = new Stack<String>();
10.     private List<String[]> resList = new ArrayList<String[]>();
11.     private int finishX;
12.     private int finishY;
13.     private int[][] multi = new int[4][2];
15.     public String[] getPath(int finishX, int finishY) {
16.         if((finishX+finishY)%2==1)
17.             return new String[0];
18.         
19.         this.finishX = finishX;
20.         this.finishY = finishY;
21.         
22.         multi[0][0] = 1;        multi[0][1] = 1;
23.         multi[1][0] = 1;        multi[1][1] = -1;
24.         multi[2][0] = -1;       multi[2][1] = 1;
25.         multi[3][0] = -1;       multi[3][1] = -1;
27.         int max = Math.abs(finishX) > Math.abs(finishY) ? Math.abs(finishX) : Math.abs(finishY);
28.         int maxIndex = 0;
29.         for (int i = 0; i < binary.length; i++) {
30.             binary[i] = 1 << i;
31.             if (binary[i] >= 2 * max) {
32.                 maxIndex = i;
33.                 break;
34.             }
35.         }
37.         resStr.add("0,0");
38.         find(0, 0, 0, maxIndex);
39.         return findMin();
40.     }
41.     
42.     private void find(int x, int y, int index, int maxIndex) {
43.         for (int i = index; i < maxIndex; i++) {
44.             if (flag[i] == 1)
45.                 continue;
46.             flag[i] = 1;
47.             for (int k = 0; k < 4; k++) {
48.                 int nextX = binary[i] * multi[k][0];
49.                 int nextY = binary[i] * multi[k][1];
50.                 resStr.push(nextX + "," + nextY);
51.                 nextX = x + nextX;
52.                 nextY = y + nextY;
53.                 if (nextX == this.finishX && nextY == this.finishY) {
54.                     resList.add(resStr.toArray(new String[0]));
55.                 }
56.                 find(nextX, nextY, i, maxIndex);
57.                 if (resStr.size() > 1)
58.                     resStr.pop();
59.             }
60.             flag[i] = 0;
61.         }
62.     }
64.     private String[] findMin() {
65.         if (resList.size() == 0)
66.             return new String[0];
67.         List<String> list = new ArrayList<String>();
69.         int x = 0, y = 0;
70.         String tmpMax = "", tmp = "", finalStr = this.finishX + ","
71.                 + this.finishY;
72.         for (String[] str : resList) {
73.             StringBuffer sb = new StringBuffer();
74.             sb.append("0,0;");
75.             int sumx = 0, sumy = 0, maxIndex = 0;
76.             for (int i = 1; i < str.length; i++) {
77.                 tmpMax = "999999;999999";
78.                 for (int k = 1; k < str.length; k++) {
79.                     if (str[k].equals("a"))
80.                         continue;
81.                     x = sumx + Integer.parseInt(str[k].split(",")[0]);
82.                     y = sumy + Integer.parseInt(str[k].split(",")[1]);
83.                     tmp = x + "," + y;
84.                     if (tmpMax.compareTo(tmp) > 0) {
85.                         tmpMax = tmp;
86.                         maxIndex = k;
87.                     }
88.                 }
89.                 sumx = sumx + Integer.parseInt(str[maxIndex].split(",")[0]);
90.                 sumy = sumy + Integer.parseInt(str[maxIndex].split(",")[1]);
91.                 sb.append(tmpMax + ";");
92.                 str[maxIndex] = "a";
93.             }
94.             list.add(sb.toString().substring(0,
95.                     sb.toString().length() - (finalStr + ";").length()));
96.         }
97.         Collections.sort(list);
98.         return (list.get(0) + finalStr).split(";");
99.     }
100. }

  算法思想：
    使用递归的方式得到所有可能的组合，由于每个k取值仅能出现一次，因此递归中使用可二次循环的结构，对于没个k分别取得它的四种取值(x + 2^k, y + 2^k)、(x + 2^k, y - 2^k)、(x - 2^k, y + 2^k)、(x - 2^k, y - 2^k)。另外由于递归的次数比较多，为了尽量加快算法速度，程序中的k取值范围定为2^k要刚好大于finishX和finishY的最大值。