引言

我们可以把{1,2,3,4,…,n}的n!个全排列按照字典序从小到大列出，例如对n=3而言，我们可以得到：

1,2,3

1,3,2

2,1,3

2,3,1

3,1,2

3,2,1

现在给出{1,2,3,4,…,n}的一个全排列，问这个全排列按字典序是第几小的？

逆康托展开

设p[0],p[1],…,p[n-1]是{1,2,…,n}的一个全排列。

令c[k]表示比p[k],p[k+1],…,p[n-1]小的{p[k],p[k+1],…,p[n-1]}的全排列的个数。

则c[0]+1便是我们要求的。

比p[k],p[k+1],…,p[n-1]小的全排列有两种类型，第一种是第一位小于p[k]的，第二种是第一位等于p[k]的，对于第一种情况而言，我们注意到这个全排列的首位可能取的值就为p[k+1],…,p[n-1]中比p[k]小的数的个数，我们记为r[k]，然后对于第一位的每一种取法，剩下的数都有(n-k-1)!种可能排列，所以第一种类型的全排列共有r[k](n-k-1)!个。

对于第二种类型的全排列，由于其第一位等于p[k]，要使得它小于p[k],p[k+1],…,p[n-1]，则必然它从第二位开始的全排列要小于p[k+1],…,p[n-1]，所以共有c[k+1]种情况。注意到这里k必须小于n，为了方便起见，我们规定c[n]=0。

于是我们得到：

c[k]=r[k](n-k-1)!+c[k+1]

c[n]=0

其中r[k]表示p[k+1],…,p[n-1]中比p[k]小的数的个数（即逆序数[1]）。

利用这个递推关系解决上面的问题的算法被称为逆康托展开。

下面是C++程序:

#include <stdio.h>
#define N (13)
int factor[N]={1};
int cantor(int*p,int n,int k);
int main()
{
	for (int i=1;i<N;++i) factor[i]=i*factor[i-1];
	int n,p[N];
	while (EOF!=scanf("%d",&n))
	{
		for (int i=0;i<n;++i) scanf("%d",p+i);
		printf("%d\n\n",1+cantor(p,n,0));
	}
	return 0;
}
int cantor(int*p,int n,int k)
{
	if (k>=n) return 0;
	int r=0;
	for (int i=k+1;i<n;++i) if (p[k]>p[i]) ++r;
	return r*factor[n-k-1]+cantor(p,n,k+1);
}

康托展开

现在考虑问题的逆问题，给出n，再给出一个整数m，问{1,2,3,…,n}的第m小的全排列是什么。

我们先把m减1.

这样m表示比所求全排列小的排列的个数。

根据刚才的逆康托展开，我们知道有m=r[0](n-1)!+r[1](n-2)!+…+r[n-1]0!

我们用(n-1)!除m，由于m=m=r[0](n-1)!+r[1](n-2)!+…+r[n-1]0!，而又可以用归纳法证明r[1](n-2)!+…+r[n-1]0!小于(n-1)!，所以根据带余除法定理,r[0]为商,r[1](n-2)!+…+r[n-1]0!为余数。

然后再用(n-2)!除r[1](n-2)!+…+r[n-1]0!，同样的可以得到r[1]。

依此进行下去，我们将得到r[0],r[1],…,r[n-1]。

现在考虑如何从 r[]反推出p[]。

对r[0]而言，由于其在首位，所以r[0]=p[0]-1，即p[0]=1+r[0]。

同样的原因，考虑p[1]的计算，显然其为不等于p[0]的第r[1]+1小的数。

而p[2]等于除p[0]，p[1]外第r[2]+1小的数，

以此类推，我们便得到全部的p[0],p[1],…,p[n-1]了。

应用

康托展开在计算机中的主要应用是作哈希函数[2]，因为它实现了整数和排列的一一对应。

参考文献

[1]Aikilis:逆序数与排序.

[2]forever zsz:康托展开.

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

引言

如果一个自然数的每位数字的立方之和等于这个数本身，则称这个数为水仙花数。比如0,1,153。

寻找某个范围类的水仙花数的任务经常作为编程教学的练习题出现，现在我想做的是寻找全部的水仙花数。

水仙花数有有穷的

注意到，任何一个位的水仙花数，根据定义，都有，另一方面，由于是一个位数，所以必然有，这样我们便得到：

解这个不等式得到。

这说明水仙花数最大是个四位数，也就是说水仙花数是有穷的，而且必定小于10000。

既然水仙花数是有穷的，而且我们找到了一个不大的上限，那么这个问题便可以通过编程而得到完美解决。

搜索程序

我们只需要找到10000以内的水仙花数，根据上面的结论，这就是全部的水仙花数。

这可以通过如下一个简单的C++程序来完成。

#include <stdio.h>
int main()
{
	for (int a=0;a<10;++a)
		for (int b=0;b<10;++b)
			for (int c=0;c<10;++c)
				for (int d=0;d<10;++d)
					if (a*a*a+b*b*b+c*c*c+d*d*d==1000*a+100*b+10*c+d)
						printf("%d\n",1000*a+100*b+10*c+d);
	return 0;
}

结论

程序运行结果显示，水仙花数非常稀少，一共只有6个：

0,1,153,370,371,407

附程序运行效果图：

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题

设，其中和分别是两个正实数序列，各自有个元素。

证明：

1. 在这两个序列的所有排列中，当两个系列都排序（非降序排序）时，取最大值。
2. 在这两个序列的所有排列中，当一个序列排成非降序，另一个序列排成非升序时，取最小值。

证明

不失一般性，这里只证明问题(1)，问题(2)类似。

假设和都已按不降序排列。

考虑，注意到任何其他的排列方式，都等价于交换中某些的值。

现在证明任何这样的交换都不会使得更大。

假设交换，其中，这将使得产生增量，这说明这样的变换不可能使得增大。

故是最大值。

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题

在黑板上写数字1,2,…,2n，其中n是奇数，从中挑出两个数j和k，在黑板上写|j-k|并擦掉j和k。继续这个过程，直到黑板上只写一个整数为止。证明：这个整数必为奇数。

证明

假设现在黑板上有个奇数和个偶数，我们任意挑出两个数。

1. 如果这两个数都为奇数，那么为偶数，那么在写上新数并擦掉旧数后，黑板上将有个奇数，个偶数。
2. 如果这两个数都为偶数，那么为偶数，那么在写上新数并擦掉旧数后，黑板上将有个奇数，个偶数。
3. 如果这两个数一奇一偶，那么为奇数，那么在写上新数并擦掉旧数后，黑板上将有个奇数，个偶数。

由上可知，不管选择怎样的两个数，黑板上奇数的个数要么不变，要么减小2，这说明不管执行多少次题述过程，黑板上奇数的个数的奇偶性都不会发生改变。

我们知道初始时有个奇数，而是一个奇数，那么不管怎样，黑板上总会有奇数个奇数，于是当黑板上只有一个数时，这个数必然是奇数。

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

引言

初中生便可以做出是无理数的证明，而我们都知道，是无理数，一般的，对于正整数，我们都默认是无理数，除了那些特别的被称为完全平方数的正整数，比如1,4,9,16,25。现在要求对这个默认的假设做出证明。

问题

是一个不是完全平方数的正整数，求证是无理数。

证明

我们知道完全平方数的算术平方根是整数，而非完全平方整数的平方根如果是有理数，那么一定是分数，所以要证明原命题，我们只需要证明不存在一个分数，它的平方是整数。

对于任意一个分数，其中是互质的整数且。

考察它的平方，若其为一个整数，必有整除，而这将与互质矛盾，因为我们若对分解质因数，由于其互质，所以不会有相同的素因子，所以和 也不会有相同的素因子，所以互质。

故不可能为整数。

原命题得证。

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题简述

给出十进制整数N和B （0<=N<=2²⁰，1<B<=800），求N!在B进制表示下的位数与末尾0的个数。

分析

一个数在进制下的位数等于：

考虑到，所以其位数可以分解为：

任意进制下阶乘末尾零的求法，与求十进制下N!末尾零的求法^[1]是相似的。

在十进制下，一个数末尾的零对应于它可以被因数分解为多少个10，同样的，一个B进制数的末尾零个数对应于它可以被因数分解为多少个B。

现在对N!分解质因数：

再对B分解质因数：

现在只需要统计X,Y,Z,…中有几组X’,Y’,Z’,…，组数就是N!末尾0的个数。

代码

#include <stdio.h>
#include <math.h>
#define ESP (1e-8)
#define N (1000)
int zero(int n,int base);
int digit(int n,int base);
int main()
{
	int n,base;
	while (EOF!=scanf("%d%d",&n,&base)) printf("%d %d\n",zero(n,base),digit(n,base));
	return 0;
}
int zero(int n,int base)
{
	int fact[N],nFact=0,i=2,t=base;
	while (i*i<=t)
		if (0==t%i)
		{
			fact[nFact++]=i;
			t/=i;
		}
		else ++i;
	if (t>1) fact[nFact++]=t;
	int uFact[N],cFact[N]={0},nUFact=0;
	for (int i=0;i<nFact;++i)
		if (i&&fact[i]==fact[i-1]) ++cFact[nUFact-1];
		else uFact[nUFact]=fact[i],cFact[nUFact]=1,++nUFact;
	int sum[N];
	for (int i=0;i<nUFact;++i)
	{
		int exp=uFact[i];
		sum[i]=0;
		while (exp<=n) {sum[i]+=n/exp;exp*=uFact[i];}
	}
	int ans=sum[0]/cFact[0];
	for (i=1;i<nUFact;++i) if (sum[i]/cFact[i]<ans) ans=sum[i]/cFact[i];
	return ans;
}
int digit(int n,int base)
{
	double sum=0;
	for (int i=1;i<=n;++i) sum+=log(i)/log(base);
	return 1+floor(ESP+sum);
}

参考文献

[1]Aikilis:阶乘末尾有多少个零.

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题简述

一些数在某些进制下可能具有“轮换乘法”性质，这是说这个数与某乘数相乘的结果等于将这个数的末位移动到首位。

下面是两个例子：

179487 * 4 = 717948，这是十进制下的例子。

17 * 4 = 71 ，这是九进制下的例子。

现在给出进制B，乘数N在B进制下的末尾D，以及另一个乘数M （0<=M<B），求满足“轮换乘法”性质的乘数N的最小位数。（B进制下）

分析

假设我们的乘数有n位，从低位到高位分别为d[0],d[1],…,d[n-1]，我们让它与m相乘，结果如下表所示：

注意到，如果令f[0]=md[0]，f[1]=md[1]+f[0]/B，f[2]=md[2]+f[1]/B，…，f[i]=md[i]+f[i-1]/B，…，f[n-1]=md[n-1]+f[n-2]/B，那么乘积从低到高的第i位就为f[i]%B。

现在考虑，如果d[n-1]，d[n-2]，…，d[0]组成满足“轮换乘法”性质的数，那么它与m相乘将呈现下表所示的结果：

现在我们将两个表得到的结果进行对比，得到：

d[1]=f[0]%B

d[2]=f[1]%B

d[3]=f[2]%B

…

d[n-1]=f[n-2]%B

d[0]=f[n-1]%B=f[n-1]

注意到这其实是递推关系：

d[i]=f[i-1]%B

f[i]=md[i]+f[i-1]/B

现在我们只需按这个关系计算f[]数组和d[]数组，直到发现f[n-1]=d[0]时，n便是所求长度。

代码

#include <stdio.h>
#define N (10000)
int f[N]={0};
int base,digit[N],m;
int main()
{
	while (EOF!=scanf("%d%d%d",&base,digit,&m))
	{
		f[0]=m*digit[0];
		if (digit[0]==f[0]) {puts("1");continue;}
		for (int i=1;i<N;++i)
		{
			digit[i]=f[i-1]%base;
			f[i]=m*digit[i]+f[i-1]/base;
			if (digit[0]==f[i])
			{
				printf("%d\n",i+1);
				break;
			}
		}
	}
	return 0;
}

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题简述

给出一组N(0<=N<=10000)，求N!的最右边的非零数字。比如5!=120，那么答案就为2。

分析

我们用f[n]保存n!的末几位非零数，然后进行递推求解。先看看只保存一位是否可以，要通过f[n-1]求解n，如果nf[n-1]末尾没有0，那么显然f[n]就等于nf[n-1]的最末位，这是因为乘积的最末位只由乘数的最末位决定，但是当nf[n-1]有一个尾0的时候就行不通了，因为要得知f[n]，也就是要得知n!的最末非零数，我们需要知道乘数的末两位，而f[n-1]只保存了末一位。如果f[n]保存末两位，则当nf[n-1]有两个尾0时便行不通了，而由于n最大为10000，由文献^[1]可知nf[n-1]最多有5个尾0，所以f[n]应当保存n!的最末6位非零数。

然后递推计算就可以了。

代码

#include <stdio.h>
#define N (10000)
int f[N+1]={1};
int main()
{
	for (int i=1;i<=N;++i)
	{
		long long t=f[i-1]*(long long)i;
		while (t%10==0) t/=10;
		f[i]=t%1000000;
	}
	int n;
	while (EOF!=scanf("%d",&n)) printf("%5d -> %d\n",n,f[n]%10);
	return 0;
}

参考文献

[1]Aikilis:阶乘末尾有多少个零.

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

计算N!的末尾有多少个0是一个经典的问题，其解法蕴含了数论问题中的一种基本思路。

我们将N!做质因子分解：

N!中的末尾0个数实际就是乘积为10的个数，而10=2*5，所以末尾0个数就是N!分解式中2和5的对数，我们知道偶数的个数远多于5的倍数的个数，所以2肯定是够用的，所以末尾0个数就等于分解式中5的个数。

所以：

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.

问题简述

给出Z,I,M和L，每个都最大是一个四位数。现在不断执行L=(ZL+I) MOD M，我们知道从某一次开始会得到以前出现过的数，这样就形成了一个环，问这个环的长度是多少。

分析

特别需要注意的是，环不一定是从第一个L开始的。

用c表示已经生成了多少个数，用一个标记数组map[i]来记录i是否出现过，用len[i]记录i第一次出现时产生了多少个不同的数（包括i ),然后不断生成L，直到发现map[L]为真，也就是L已经出现过，这时c-len[L]+1就是环的长度。

代码

#include <stdio.h>
#include <math.h>
#define N (10000)
int main()
{
	int l,z,i,m,iCase=0;
	while (scanf("%d%d%d%d",&z,&i,&m,&l),z||i||m||l)
	{
		int map[N]={0},c=0,len[N]={0};
		while (!map[l])
		{
			++c;
			map[l]=1;
			len[l]=c;
			l=(z*l+i)%m;
		}
		printf("Case %d: %d\n",++iCase,c-len[l]+1);
	}
	return 0;
}

© 2012, Aikilis. 版权所有. 转载请注明出自http://aikilis.tk/.