16. 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

Solution: (Permutation with conditions)

class Solution
{
public:
    int count = 0;
    
    void countBeautifulPerm(vector<int> &v, int n, int pos)
    {
          
        if (pos == n + 1)
        {
            count++;
            return;
        }

        for (int i = pos; i <= n; i++)
        {

            swap(v[i], v[pos]);
            if (pos % v[pos] == 0 || v[pos] % pos == 0)
            { 
                countBeautifulPerm(v, n, pos + 1);
            }
            swap(v[i], v[pos]);
        }

        return;
    }

    int countArrangement(int n)
    {
        vector<int> v;
        v.push_back(0);

        for (int i = 1; i <= n; i++)
        {
            v.push_back(i);
        }

        countBeautifulPerm(v, n, 1);

        return count;
    }
};