【LeetCode】526. Beautiful Arrangement

问题描述

问题链接：https://leetcode.com/problems/beautiful-arrangement/#/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:

N is a positive integer and will not exceed 15.

我的代码

有个思路是找出所有的排列，然后判断，但是没写出来。看了讨论区，都是用的回溯法。就去学了一下，然后写了个代码。

public class Solution {

    private int count = 0;

    public int countArrangement(int N) {
        /*
        思路是使用回溯法。如果当前的解满足要求，就继续向下走去探索子节点，否则就返回
        是一种优秀的剪枝算法
        */
        int[] nums = new int[N + 1];
        for(int i = 1; i <= N; i++){
            nums[i] = i;
        }
        backTracking(nums,1);
        return count;
    }

    private void backTracking(int[] nums, int start){
        if(start >= nums.length){
            count++;  // 找到一个解
            return;
        }

        for(int i = start; i < nums.length; i++){
            swap(nums,i,start);
            if(nums[start] % start == 0 || start % nums[start] == 0){ // 子节点可能有解
                backTracking(nums,start + 1);
            }
            swap(nums,start,i);
        }
    }

    private void swap(int[] nums, int from, int to){
        int temp = nums[from];
        nums[from] = nums[to];
        nums[to] = temp;
    }
}

打败了79.89%的代码。来看看讨论区

讨论区

12 ms Java Backtracking sulotion

也是用的回溯法。

public class Solution {
    public int countArrangement(int N) {
        dfs(N, N, new boolean[N + 1]);
        return count;
    }

    int count = 0;

    void dfs(int N, int k, boolean[] visited) {
        if (k == 0) {
            count++;
            return;
        }
        for (int i = 1; i <= N; i++) {
            if (visited[i] || k % i != 0 && i % k != 0) {
                continue;
            }
            visited[i] = true;
            dfs(N, k - 1, visited);
            visited[i] = false;
        }
    }
}