Leetcode 526. Beautiful Arrangement

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 ithposition (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.

class Solution:
    def DFS(self, N, glist, start, chosen):
        if start == N+1:
            self.count += 1
            return
        llist = glist[start-1]
        for i,ele in enumerate(llist):
            if ele in chosen:
                continue
            chosen.add(ele)
            self.DFS(N, glist, start+1, chosen)
            chosen.discard(ele)
        return
    
    def countArrangement(self, N):
        """
        :type N: int
        :rtype: int
        """
        glist = []
        for i in range(1,N+1):
            llist = []
            for j in range(1,i+1):
                if i%j == 0:
                    llist.append(j)
            for j in range(i+1,N+1):
                if j%i == 0:
                    llist.append(j)
            glist.append(llist[:])
        self.count = 0
        chosen = set()
        self.DFS(N, glist, 1, chosen)
        return self.count

 

Above is my solution. First build the candidate list. Then loop thru it using DFS. Each time pick one and solve the rest.

Good: Clear

Bad: This DFS approach can NOT be changed to use memo approach to optimization. In fact, this code can only beat 40% python submissioin on LC

 

cache = {}
class Solution(object):
    def countArrangement(self, N):
        def helper(i, X):
            if i == 1:
                return 1
            key = (i, X)
            if key in cache:
                return cache[key]
            total = 0
            for j in xrange(len(X)):
                if X[j] % i == 0 or i % X[j] == 0:
                    total += helper(i - 1, X[:j] + X[j + 1:])
            cache[key] = total
            return total
        return helper(N, tuple(range(1, N + 1)))

The above approach presented by zhongyuan9817 here: https://leetcode.com/problems/beautiful-arrangement/discuss/99717/Python-recursion-%2B-DP-66ms

is better in that: 1) it's cacheable/Memorizable; 2) It select the eligible list on the fly!

How he achieved this? First, reduce the problem size N -> N-1; Second, in the reduced the size of problem, pick ONE out that's valid for this ith position, and then

recurse to the smaller problem. 

虽然同样是DFS，但是答案的构造方向是不一样的！我所使用的是从上到下，必须全程走一遍才能得到答案，不利于Memorization！zhongyuan9817 提供的DFS的答案是从下而上

构造出来的，可以用记忆化方法加速！这个区别应该理解和注意！