1到N，N个数的排列，求解任意两连续数字不相邻的方案数

已于 2022-09-22 22:56:22 修改
阅读量1.1k 收藏
点赞数 2
分类专栏： 题解 文章标签： 算法
于 2022-09-22 20:47:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62817228/article/details/126999223
版权

题目来源：

264：阿岳真的很严格

大致题意：

输入n

从1到n 共n个数 在所有的排列中 任意两个连续的数字不相邻的排列有多少种

例如：

输入n等于4时  输出2 有两种

分别是3 1 4 2和2 4 1 3 都是满足要求的合法排列

其他排列都不符合要求 例如1 4 2 3中2和3连续 不合法

解法1：O（N）的一维DP

用n表示输入 用f【n】表示对应的输出

1-5的f【n】用DFS暴力跑 之后的DP 

状态转移方程：

f[i] = (i + 1) * f[i - 1] - (i - 2) * f[i - 2] - (i - 5) * f[i - 3] + (i - 3) * f[i - 4];

f【n】即为答案

解法2：O（N*N）的二维DP

f[0/1][i][j]:0/1表示i和i-1这两个数是否连续 i表示1到i i个数的情况 j表示在i个数中有j对数连续的情况

即，i和i-1 不连续/连续 一共i个数 其中有j对数连续的方案数是f【0/1】【i】【j】

i为1-5的所有情况DFS暴力跑 之后二维DP

状态转移方程：

f[0][i][j] = f[0][i - 1][j + 1] * (j + 1) + f[1][i - 1][j + 1] * j + f[0][i - 1][j] * (i - j - 2) + f[1][i - 1][j] * (i - j - 1);

f[1][i][j] = f[1][i - 1][j - 1] + f[1][i - 1][j] + f[0][i - 1][j - 1] * 2;

f【0】【n】【0】即为答案

UPD1:

解法2可以把f[0][1][0]设为1 其他设为0 直接从2开始遍历DP 不需要DFS跑前几个

AC代码1：

// #define NDEBUG
#include <bits/stdc++.h>
using namespace std;
namespace AIN
{
	using db = double;
	using ll = long long;
#define edl '\n'
#define str string
#define pll pair<ll, ll>
#define fir first
#define sec second
#define heap priority_queue
#define SPO(n) fixed << setprecision(n)
#define FOR(i, l, r) for (auto i = l; i <= (r); ++i)
#define ROF(i, r, l) for (auto i = r; i >= (l); --i)
#ifdef debugcmd
#define DBG(n) cout << "!!! " << #n << ": " << n << edl
#else
#define DBG(n) ;
#endif
	template <typename T>
	T KSM(T base, long long exp)
	{
		// assert(exp >= 0);
		T res = 1;
		while (exp)
		{
			if (exp & 1)
				res *= base;
			base *= base;
			exp >>= 1;
		}
		return res;
	}
	long long __lcm(long long lhs, long long rhs) { return lhs / __gcd(lhs, rhs) * rhs; }
	// constexpr db PI = acos(-1.0);
	// constexpr db EPS = 1.0e-9;
	constexpr long long LNF = 0x3f3f3f3f3f3f3f3fLL;
	constexpr int INF = 0x3f3f3f3f;
	// constexpr long long MOD = 998244353;
	// constexpr long long MOD = 1e9 + 7;
	constexpr long long MOD = 7777777;
	constexpr int MXN = 1e5 + 5;
}
using namespace AIN;
template <long long P>
struct ModInt
{
public:
	ModInt() : _v(0) {}
	template <typename T>
	ModInt(T v) { _v = ((long long)v % P + P) % P; }
	long long val() const { return _v; }
	ModInt &operator++()
	{
		++_v;
		if (_v == P)
			_v = 0;
		return *this;
	}
	ModInt &operator--()
	{
		if (_v == 0)
			_v = P;
		--_v;
		return *this;
	}
	ModInt operator++(int)
	{
		ModInt oldVal = *this;
		++*this;
		return oldVal;
	}
	ModInt operator--(int)
	{
		ModInt oldVal = *this;
		--*this;
		return oldVal;
	}
	ModInt &operator+=(const ModInt &rhs)
	{
		_v += rhs._v;
		_v %= P;
		return *this;
	}
	ModInt &operator-=(const ModInt &rhs)
	{
		_v -= rhs._v;
		_v = (_v + P) % P;
		return *this;
	}
	ModInt &operator*=(const ModInt &rhs)
	{
		_v *= rhs._v;
		_v %= P;
		return *this;
	}
	ModInt &operator/=(const ModInt &rhs) { return *this = *this * rhs.inv(); }
	ModInt operator+() const { return *this; }
	ModInt operator-() const { return ModInt() - *this; }
	ModInt pow(long long exp) const
	{
		// assert(exp>=0);
		ModInt res = 1;
		ModInt base = *this;
		while (exp)
		{
			if (exp & 1)
				res *= base;
			base *= base;
			exp >>= 1;
		}
		return res;
	}
	ModInt inv() const
	{
		// assert(_v);
		return pow(P - 2);
	}
	friend ModInt operator+(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res += rhs;
		return res;
	}
	friend ModInt operator-(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res -= rhs;
		return res;
	}
	friend ModInt operator*(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res *= rhs;
		return res;
	}
	friend ModInt operator/(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res /= rhs;
		return res;
	}
	friend bool operator==(const ModInt &lhs, const ModInt &rhs) { return lhs._v == rhs._v; }
	friend bool operator!=(const ModInt &lhs, const ModInt &rhs) { return lhs._v != rhs._v; }
	friend std::istream &operator>>(std::istream &is, ModInt &aim)
	{
		long long tmp;
		is >> tmp;
		aim = ModInt(tmp);
		return is;
	}
	friend std::ostream &operator<<(std::ostream &os, const ModInt &aim) { return os << aim.val(); }

private:
	long long _v;
};
using mint = ModInt<MOD>;

ll n;
mint f[MXN];

void Init(void)
{
	f[1] = 1;
	f[2] = 0;
	f[3] = 0;
	f[4] = 2;
	f[5] = 14;
	FOR(i, 6, 1e3 + 5)
	f[i] = (i + 1) * f[i - 1] - (i - 2) * f[i - 2] - (i - 5) * f[i - 3] + (i - 3) * f[i - 4];
	return;
}
void Solve(void)
{
	cout << f[n] << edl;
	return;
}
int main(void)
{
	std::ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	// #ifdef cincoutcmd
	// freopen("cin.txt","r",stdin);
	// freopen("cout.txt","w",stdout);
	// #endif
	Init();
	while (cin >> n)
		Solve();
	return 0;
}

AC代码2：

// #define NDEBUG
#include <bits/stdc++.h>
using namespace std;
namespace AIN
{
	using db = double;
	using ll = long long;
#define edl '\n'
#define str string
#define pll pair<ll, ll>
#define fir first
#define sec second
#define heap priority_queue
#define SPO(n) fixed << setprecision(n)
#define FOR(i, l, r) for (auto i = l; i <= (r); ++i)
#define ROF(i, r, l) for (auto i = r; i >= (l); --i)
#ifdef debugcmd
#define DBG(n) cout << "!!! " << #n << ": " << n << edl
#else
#define DBG(n) ;
#endif
	template <typename T>
	T KSM(T base, long long exp)
	{
		// assert(exp >= 0);
		T res = 1;
		while (exp)
		{
			if (exp & 1)
				res *= base;
			base *= base;
			exp >>= 1;
		}
		return res;
	}
	long long __lcm(long long lhs, long long rhs) { return lhs / __gcd(lhs, rhs) * rhs; }
	// constexpr db PI = acos(-1.0);
	// constexpr db EPS = 1.0e-9;
	constexpr long long LNF = 0x3f3f3f3f3f3f3f3fLL;
	constexpr int INF = 0x3f3f3f3f;
	// constexpr long long MOD = 998244353;
	// constexpr long long MOD = 1e9 + 7;
	constexpr long long MOD = 7777777;
	constexpr int MXN = 1e3 + 5;
}
using namespace AIN;
template <long long P>
struct ModInt
{
public:
	ModInt() : _v(0) {}
	template <typename T>
	ModInt(T v) { _v = ((long long)v % P + P) % P; }
	long long val() const { return _v; }
	ModInt &operator++()
	{
		++_v;
		if (_v == P)
			_v = 0;
		return *this;
	}
	ModInt &operator--()
	{
		if (_v == 0)
			_v = P;
		--_v;
		return *this;
	}
	ModInt operator++(int)
	{
		ModInt oldVal = *this;
		++*this;
		return oldVal;
	}
	ModInt operator--(int)
	{
		ModInt oldVal = *this;
		--*this;
		return oldVal;
	}
	ModInt &operator+=(const ModInt &rhs)
	{
		_v += rhs._v;
		_v %= P;
		return *this;
	}
	ModInt &operator-=(const ModInt &rhs)
	{
		_v -= rhs._v;
		_v = (_v + P) % P;
		return *this;
	}
	ModInt &operator*=(const ModInt &rhs)
	{
		_v *= rhs._v;
		_v %= P;
		return *this;
	}
	ModInt &operator/=(const ModInt &rhs) { return *this = *this * rhs.inv(); }
	ModInt operator+() const { return *this; }
	ModInt operator-() const { return ModInt() - *this; }
	ModInt pow(long long exp) const
	{
		// assert(exp>=0);
		ModInt res = 1;
		ModInt base = *this;
		while (exp)
		{
			if (exp & 1)
				res *= base;
			base *= base;
			exp >>= 1;
		}
		return res;
	}
	ModInt inv() const
	{
		// assert(_v);
		return pow(P - 2);
	}
	friend ModInt operator+(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res += rhs;
		return res;
	}
	friend ModInt operator-(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res -= rhs;
		return res;
	}
	friend ModInt operator*(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res *= rhs;
		return res;
	}
	friend ModInt operator/(const ModInt &lhs, const ModInt &rhs)
	{
		ModInt res = lhs;
		res /= rhs;
		return res;
	}
	friend bool operator==(const ModInt &lhs, const ModInt &rhs) { return lhs._v == rhs._v; }
	friend bool operator!=(const ModInt &lhs, const ModInt &rhs) { return lhs._v != rhs._v; }
	friend std::istream &operator>>(std::istream &is, ModInt &aim)
	{
		long long tmp;
		is >> tmp;
		aim = ModInt(tmp);
		return is;
	}
	friend std::ostream &operator<<(std::ostream &os, const ModInt &aim) { return os << aim.val(); }

private:
	long long _v;
};
using mint = ModInt<MOD>;

const ll LIM = 1e3 + 3;
ll n;
mint f[2][MXN][MXN];
bool vis[MXN];
ll v[MXN];
ll p[MXN];

void Init(ll n)
{
	FOR(i, 1, n)
	vis[i] = false;
	v[0] = -1;
	p[0] = -1;
	return;
}
void DFS(ll pos, ll num, ll len)
{
	if (pos == len)
	{
		ll flag = 0;
		if (p[len] == p[len - 1] + 1 || p[len] == p[len - 1] - 1)
			flag = 1;
		ll cnt = 0;
		FOR(i, 1, len - 1)
		if (v[i] == v[i + 1] + 1 || v[i] == v[i + 1] - 1)
			++cnt;
		++f[flag][len][cnt];
		return;
	}
	FOR(i, 1, len)
	{
		if (!vis[i])
		{
			vis[i] = true;
			v[pos + 1] = i;
			p[i] = pos + 1;
			DFS(pos + 1, i, len);
			vis[i] = false;
		}
	}
	return;
}
void Pre(void)
{
	FOR(i, 1, 5)
	{
		Init(i);
		DFS(0, -1, i);
	}
	FOR(i, 6, LIM)
	FOR(j, 0, i - 1)
	{
		f[0][i][j] = f[0][i - 1][j + 1] * (j + 1) + f[1][i - 1][j + 1] * j + f[0][i - 1][j] * (i - j - 2) + f[1][i - 1][j] * (i - j - 1);
		f[1][i][j] = f[1][i - 1][j - 1] + f[1][i - 1][j] + f[0][i - 1][j - 1] * 2;
	}
	return;
}
void Solve(void)
{
	cout << f[0][n][0] << edl;
	return;
}
int main(void)
{
	std::ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	// #ifdef cincoutcmd
	// freopen("cin.txt","r",stdin);
	// freopen("cout.txt","w",stdout);
	// #endif
	Pre();
	while (cin >> n)
		Solve();
	return 0;
}

AINgray
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2014-09-1 相邻数对(排序)
S-L-L-Q的博客
03-11 239
给定 n 个不同的整数，问这些数中有多少对整数，它们的值正好相差 1。 输出格式 输入的第一行包含一个整数 n，表示给定整数的个数。 第二行包含所给定的 n 个整数。 输出格式 输出一个整数，表示值正好相差 1 的数对的个数。 数据范围 1≤n≤1000, 给定的整数为不超过 10000 的非负整数。 输入样例： 6 10 2 6 3 7 8 输出样例： 3 样例解释 值正好相差 1 的数对包括 (2,3),(6,7),(7,8)。 C++： /* 先排序 然后遍历一遍判断差值为1 即可 */ #i
python贪心算法求删数问题_算法讲解之贪心算法
weixin_29189381的博客
01-14 1016
贪心算法思路若在求解一个问题时，能根据每次所得到的局部最优解，推导出全局最优或最优目标。那么，我们可以根据这个策略，每次得到局部最优解答，逐步而推导出问题，这种策略称为贪心法【例1】在N行M列的正整数矩阵中，要求从每行中选出1个数，使得选出的总共N个数的和最大。【算法分析】要使总和最大，则每个数要尽可能大，自然应该选每行中最大的那个数。因此，我们设计出如下算法:读入N, M,矩阵数据；Total ...
暑假练习1-1 字典序算法，从1到n的全排列
xianqiuyigedao的博客
07-02 980
从1到n的全排列。 题干： 输入一个整数n（n <= 9），输出1、2、3、······、n这n个数的全排列（按照字典序输出）。 Input 一个整数n Output 多行，每行表示一种排列，行内使用空格分隔相邻两数。 Sample Input 3 Sample Output 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 **思路：**参考了https://blog.csdn.net/Horizenn/article/details/82380296 对于这种全排列，人写是简
【Python蓝桥杯】数字游戏 给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
Insight__的博客
03-02 2238
【Python蓝桥杯】数字游戏 给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
相邻的数字不能相同的排列个数的求取(代码源div2每日一题:一个小整数)
计算机不太聪明的博客
08-12 556
如题
求一组数据中，相邻的两个数字之差的绝对值最小的一对数字
G小胖的博客
08-11 1544
题目：给出n个正整数，要求找出相邻的两个数字中差的绝对值最小的一对数字，如果有其他两个数差的绝对值相同，则输出在最前面的一对数。2<n<=100,正整数都在10^16范围内。 输入：输入包含两行，第一行为n，第二行是用n个空格分隔的的正整数 输出：输出包含一行两个正整数，要求按照原来的顺序输出 样例输入： 代码实现： #include <iostream> ...
由n个不同元素A1，A2，…,An构成的A1，A2不相邻的全排列个数有多少？
最新发布
06-09
初始条件为 $f(1) = 1$，$f(2) = 1$，因为只有一个元素或两个元素时，不存在 $A_1, A_2$ 不相邻的情况。 最终，根据递推式可以计算出 $f(n)$ 的值。时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。
排列的两个计数问题 (1984年)
04-25
n,n\)构成的排列\(a_1a_2...a_{2n}\)，其连贯数定义为排列中相邻两个相同的数字对之间包含的不同数字数量加上\(n\)。例如，对于排列\(221133\)，连贯数为\(n+0\)，而对于排列\(121323\)，连贯数为\(n+1\)。这样的...
题解：素数环
m0_61100182的博客
08-08 1533
搜索与回溯是计算机解题中常用的算法，很多问题无法根据某种确定的计算法则来求解，可以利用搜索与回溯的技术求解。回溯是搜索算法中的一种控制策略。它的基本思想是：为了求得问题的解，先选择某一种可能情况向前探索，在探索过程中，一旦发现原来的选择是错误的，就退回一步重新选择，继续向前探索，如此反复进行，直至得到解或证明无解。......
利用粒子群优化算法求解圆排列问题.pdf
09-29
在圆排列问题中，目标是找到一个圆形排列的序列，使得任意两个相邻元素之间的距离之和最小。该问题在很多实际应用中都有其重要性，例如在电路设计、物流规划等领域。 文章首先分析了圆排列问题与旅行商问题之间的...
排列组合的一个问题
12-26
一个长度为N的排列，由数字1-N组成，它满足两个条件： 1.数字1永远在第一位， 2.任意两个相邻数之差小于等于2。 现在给出一个N，你知道能组成多少个符合条件的排列吗？ 例如： n=4 1 2 3 4 1 2 4 3 1 3 2 4 1 3 4 2 所有答案为4.
组合数学——不相邻的组合数
Anonymous_jsu的博客
10-07 1291
一、从n个球中选出r个球，要求这r个球互不相邻，有多少种取法？ 分析： ①当n<2r-1时，取法为0种 例如4个球里取3个互不相邻的球，找不到这样的组合 ②n≥2r-1时，取法为C(n-r+1,r)种 这里考虑逆向思维。假设我们先从n-r+1个球中任意取r个球，组合数为C(n-r+1,r)，然后再另外拿r-1个球插到那r个球的r-1个空位中，这样使得我们原本取出的r个球都互不相邻，并且最后总球数为n个。不难验证逆向思维得出的情况与正常考虑的情况是一一对应的，故我们可以得到上面的结论。 （临界情况：n=
排序
AI蜗牛之家
07-17 1313
#include #include #include #include using namespace std; int main() {  int x,d,i,j,a[1500],n,w;  scanf("%d",n);  for(w=1;w  {   scanf("%d,%d",x,d);         int all=1;   for(i=0;i   s
拼多多笔试：种树
weixin_30379973的博客
07-27 958
题目描述： 链接：https://www.nowcoder.com/questionTerminal/52f25c8a8d414f8f8fe46d4e62ef732c来源：牛客网小多想在美化一下自己的庄园。他的庄园毗邻一条小河，他希望在河边种一排树，共 M 棵。小多采购了 N 个品种的树，每个品种的数量是 Ai (树的总数量恰好为 M)。但是他希望任意两棵相邻的树不是同一品种的。小多...
实现数字1到数字n的全排列（连续数字）
qq_43337016的博客
05-12 1826
#include <iostream> #include<cstdio> const int max=1100; int n,p[max],hashTable[max]={false};//hashTable用来记录数字是否已排列 //递归求数字全排列； void func(int index){ int i; if(index==n+1){ ...
素数环 C++
flipped__love的博客
06-12 2679
回溯法 【问题描述】 将1到n这n个数摆成一个环，要求任意相邻的两个数的和都是素数。输出方案总数。注意：以下8种序列属于同一种方案： ①1 2 3 4； ②2 3 4 1； ③3 4 1 2； ④4 1 2 3； ⑤1 4 3 2； ⑥4 3 2 1； ⑦3 2 1 4； ⑧2 1 4 3。 【输入格式】 只有一行包含一个正整数n（2<=n<=18） 【输出格式】 一行包含一个整数，即方案种数。 【输入样例】 4 【输出样例】 1 分析一下： 这题用的是搜索与回溯。 暴力枚举然后判断相邻两数之和
ACM素数环问题（c++和python3）
qq_33163046的博客
12-09 6283
素数环是一个由数字 1, 2, ..., n 构成的圆环，其中任意两个相邻数字之和均为素数，圆环中的数字不能重复。 - Input: 输入包含多组测试数据，每组数据占一行，为素数环的大小 n (0 < n < 18)。 - Output: 对于每组数据，按字典序大小，输出所有素数环的排列方案，排列方案的第一个数字必须是 1，每组数据后要输出一个空行。
【DFS练习】素数环
z135733的博客
01-29 2968
DFS+回溯+剪枝，同时用空间换时间。
2023.3.29 练习携程一轮3.7笔试题（牛客找的，附本人部分题解）+3.29二轮笔试题（亲自考的）
cxfool的博客
03-30 1163
超市开展了一个活动， 当游游花费原价买了一件商品时，她可以用半价买下一件右边相邻的商品(也可以用原价购买，这样该商品右边的商品就有 一次享受半价的机会)。游游准备开车出游，她的车非常特殊，油越多则最高速度越快，即最高速度和油量是成正比的。游游初始的钱为 x，她想要买的商品的喜爱度总和尽可能大，但总价格不能超过 x，你能帮帮她计算最大的喜爱度总和吗?游游正在逛超市，有n个商品摆成排，第个商品的价格为ai,游游对它的真爱度为b。换言之，如果游游想要半价买某一件商品，必须先用原价买下它相邻的左边的那个商品。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值