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:
- The number at the ith position is divisible by i.
- 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.
Subscribe to see which companies asked this question.
对每个位置，判断是不是能够整除
现在问题是，被注释掉的只是一个普通的广搜，并是不回溯，n=10的时候，超时了
后面是回溯的算法。
现在的一个需要注意的是，对于回溯问题，有一种方式就是，其中是否访问过，可以用visited标记，而不是用数字一个个塞进去
class Solution(object):
def countArrangement(self, N):
'''
def check(num):
#print 'check',num
for i in range(len(num)):
if num[i] % (i+1) != 0 and (i+1) % num[i] != 0:
return 0
return 1
def bt(pos,res,n,num):
if pos == n:
res += check(num)
return res
for i in xrange(0,pos+1):
temp = num[:i]+[pos+1]+num[i:]
res = bt(pos+1,res,n,temp)
return res
return bt(1,0,N,[1])
'''
self.res = 0
def bt(N,pos,visited):
if pos > N:
self.res += 1
#print self.res
return
for i in xrange(1,N+1):
#print i,N+1
if visited[i] == 0 and (i % pos == 0 or pos % i == 0):
#print i,N,pos,visited,self.res
visited[i] = 1
bt(N,pos+1,visited)
visited[i] = 0
bt(N,1,[0]*(N+1))
return self.res
"""
:type N: int
:rtype: int
"""