[LeetCode January Challange] Day 3 - Beautiful Arrangement

Suppose you have n integers labeled 1 through n. A permutation of those n integers perm (1-indexed) is considered a beautiful arrangement if for every i (1 <= i <= n), either of the following is true:

• perm[i] is divisible by i.
• i is divisible by perm[i].

Given an integer n, return the number of the beautiful arrangements that you can construct.

Example 1:

Input: n = 2
Output: 2
Explanation: 
The first beautiful arrangement is [1,2]:
    - perm[1] = 1 is divisible by i = 1
    - perm[2] = 2 is divisible by i = 2
The second beautiful arrangement is [2,1]:
    - perm[1] = 2 is divisible by i = 1
    - i = 2 is divisible by perm[2] = 1

Example 2:

Input: n = 1
Output: 1

Constraints:

• 1 <= n <= 15

---

Solution

Time complexity : O(k) # k perms
Space complexity : O(n)

class Solution {
public:
    int countArrangement(int n) {
        count = 0;
        vector<bool> visited(n+1, false);
        
        backtracking(n, 1, visited);
            
        return count;
    }
    
    void backtracking(int n, int pos, vector<bool> &visited) {
        if (pos > n) ++count;
        for (int i=1; i<=n; ++i) {
            if (!visited[i] && (i % pos == 0 || pos % i == 0)) {
                visited[i] = true;
                backtracking(n, pos+1, visited);
                visited[i] = false;
            }
        }
    }
    
private:
    int count;
};

利用 visited 做 backtracking ，要放新數字時做檢查，若已不合所需，則代表它為根之後的 perm 都是錯的，不用再往下做，直接跳下一個，避免不需要的計算。