LeetCode 526. 优美的排列

假设有从 1 到 n 的 n 个整数。用这些整数构造一个数组 perm（下标从 1 开始），只要满足下述条件 之一 ，该数组就是一个 优美的排列 ：

perm[i] 能够被 i 整除
i 能够被 perm[i] 整除
给你一个整数 n ，返回可以构造的 优美排列 的 数量 。

示例 1：

输入：n = 2
输出：2
解释：
第 1 个优美的排列是 [1,2]：
    - perm[1] = 1 能被 i = 1 整除
    - perm[2] = 2 能被 i = 2 整除
第 2 个优美的排列是 [2,1]:
    - perm[1] = 2 能被 i = 1 整除
    - i = 2 能被 perm[2] = 1 整除
示例 2：

输入：n = 1
输出：1
 

提示：

1 <= n <= 15

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/beautiful-arrangement
 

解法一：状压dp。

本题数据范围1<=n<=15,并且涉及到排列组合。对于我个人而言比较好理解的是dp(i,mask)表示放入第i个数的状态为mask时，共有多少中排列数量。其中mask为n位二进制整数。

dp[i][mask]+=dp[i-1][mask^(1<<j)],其中j表示mask的第j位为1；

class Solution {



public:
	int countArrangement(int n) {
		int top = 1 << n;
		vector<vector<int>> dp(n + 1, vector<int>(top, 0));
		dp[0][0] = 1;
		for (int i = 1; i <= n; ++i)
		{
			for (int mask = 0; mask < top; ++mask)
			{
				if (__builtin_popcount(mask) == i)    //mask中1的个数要等于i，表示前i个数
				{
					//dp[i][mask] = dp[i - 1][mask];
					for (int j = 0; j < n; ++j)
					{
						if ((mask & 1 << j)&&(i%(j+1)==0||(j+1)%i==0))
						{
							dp[i][mask] += dp[i - 1][mask^(1<<j)];
						}
					}
				}
			}
		}
		return dp[n][top - 1];
	}
};

但此时我们可以发现，dp[i]的状态只与dp[i-1]有关，并且mask从0到（1<<n）递增，涵盖了所有的排列，其中mask中1的个数就表示当前数的个数。可以优化为如下代码，该代码时间复杂度为O（）,空间复杂度为O()。

class Solution {



public:
	int countArrangement(int n) {
		int top = 1 << n;
		vector<int> dp(top, 0);
		dp[0] = 1;
        for (int mask = 0; mask < top; ++mask)
        {
            int num=__builtin_popcount(mask);
            //dp[i][mask] = dp[i - 1][mask];
            for (int j = 0; j < n; ++j)
            {
                if ((mask & 1 << j)&&(num%(j+1)==0||(j+1)%num==0))
                {
                    dp[mask] += dp[mask^(1<<j)];
                }
            }
        }
		return dp[top - 1];
	}
};

解法二：回溯

通常可以进行自底向上的dp，也就可以进行自顶向下的回溯，况且一个数组的全排列就可以通过回溯求得。

class Solution {

    int dfs(int x,const int& n, vector<int> &vis)
    {
        if(x==n+1)
            return 1;
        int cnt=0;
        for(int i=1;i<=n;++i)
        {
            if(!vis[i]&&(x%i==0||i%x==0))
            {
                vis[i]=true;
                cnt+=dfs(x+1, n, vis);
                vis[i]=false;
            }
        }
        return cnt;
    }
public:
	int countArrangement(int n) {
        vector<int> vis(n+1);
		return dfs(1, n, vis);
		
	}
};

本以为会超时，因为15！都超过int了，但实际上有能否整除这个限定条件，会有许多情况不需要遍历。官方题解中对每个位置可以匹配的数字进行预处理，之后搜索的时候只对可以匹配的数字进行搜索。