LeetCode[526]Beautiful Arrangement(Java)

Description:

Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1 <= i <= N) in this array:

1. The number at the ith position is divisible by i.
2. i is divisible by the number at the ith position.

Now given N, how many beautiful arrangements can you construct?

Example 1:

Input: 2
Output: 2
Explanation: 

The first beautiful arrangement is [1, 2]:

Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).

Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).

The second beautiful arrangement is [2, 1]:

Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).

Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.

Note:

1. N is a positive integer and will not exceed 15.

Solution:

Backtracing(回溯法)

回溯法是暴力求解的优化，在遍历所有情况的过程中，一旦出现不符合要求的情况，则将该次遍历终止。将不能的解尽早舍弃。

设置一个递归函数，函数的参数携带当前解的信息，根据这些参数判断当前情况是可能解(记录或打印结果)或者不能解(回溯)。

Pick a starting point.
while(Problem is not solved)
	For each path from the starting point.
		check if selected path is safe, if yes select it
                and make recursive call to rest of the problem
		If recursive calls returns true, then return true.
		else undo the current move and return false.
	End For
	If none of the move works out, return false, NO SOLUTON.

Pick a starting point.
search(params)
	For each path from the starting point.
		check if selected path is safe, if yes select it
                and make recursive call to rest of the problem(search(new params))
		If recursive calls returns true, then return true.
		else undo the current move and return false.
	End For
	If none of the move works out, return false, NO SOLUTON.

class Solution {
    int result = 0;
    public int countArrangement(int N) {
        boolean[] visited = new boolean[N + 1];
        count(N, 1, visited);
        return result;
    }
    public void count(int N, int current, boolean[] visited){
        if(current > N){
            result++;
            return;
        }
        for(int i = 1; i <= N; i++){
            if(!visited[i] && (current % i == 0 || i % current == 0)){
                visited[i] = true;
                count(N, current + 1, visited);
                visited[i] = false;
            }
        }
    }
}