第几是谁(NYOJ)

康托展开与逆运算解析
本文详细介绍了康托展开及其逆运算的概念与应用,包括如何通过康托展开确定一个排列在所有可能排列中的位置,以及如何从指定位置逆向求出对应的排列。通过具体的代码实现,帮助读者深入理解这一数学工具。


第几是谁?

时间限制:3000 ms  |  内存限制:65535 KB
难度:3
描述
现在有"abcdefghijkl”12个字符,将其按字典序排列,如果给出任意一种排列,我们能说出这个排列在所有的排列中是第几小的。但是现在我们给出它是第几小,需要你求出它所代表的序列.
输入
第一行有一个整数n(0<n<=10000);
随后有n行,每行是一个整数m,它代表着序列的第几小;
输出
输出一个序列,占一行,代表着第m小的序列。
样例输入
3
1
302715242
260726926
样例输出
abcdefghijkl
hgebkflacdji
gfkedhjblcia



 
#include<stdio.h>
#include<string.h>
long int fac[13] = {1,1};
char s[12];
int a[12];
void find(int len, int n);


int main()
{
int n,len = 12;//len是字符串长度;
int i,m;
for(i = 2; i < 12; i++)//计算阶乘
fac[i] = i*fac[i -1];
// printf("%ld\n",fac[11]);
scanf("%d",&m);
for(i = 0; i < m;i++)
{
memset(s,'0',sizeof(s));
memset(a, 0, sizeof(a));
scanf("%d",&n);
find(len, n);
printf("%s\n",s);
}
return 0;
}


void find(int len, int n)
{
int temp;
int i,k;
n--;
for(i = 0; i < len - 1; i++)
{
temp = n / fac[len - i -1];//temp是记录录比当前位小的字母个数;
//printf("t =%d\n",temp);
n = n % fac[len - i -1];//n取余;

k = 0;
for(k = 0; k <= temp; k++)//在已存入得字母中找当前找到的字母是否在前面出现过或者是前面有比他小的
if(a[k])
temp++;

s[i] = temp + 97;

a[temp] = 1;
}
i = 0;
while(a[i])//最后剩下的就是最后一个;
i++;
s[len - 1] = i + 97;
}        





题目:给出n个互不相同的字符, 并给定它们的相对大小顺序,这样n个字符的所有排列也会有一个顺序. 现在任给一个排列,求出在它后面的第i个排列.
这是一个典型的康拓展开应用,首先我们先阐述一下什么是康拓展开。


(1)康拓展开


  所谓康拓展开是指把一个整数X展开成如下形式:


  X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[2]*1!+a[1]*0!。(其中,a为整数,并且0<=a[i]<i(1<=i<=n))


(2)应用实例


  {1,2,3,4,...,n}表示1,2,3,...,n的排列如 {1,2,3} 按从小到大排列一共6个:123 132 213 231 312 321。他们间的对应关系可由康托展开来找到。


  1324是{1,2,3,4}排列数中第几个大的数:
  第一位是1小于1的数没有,是0个 0*3! ;
  第二位是3小于3的数有1和2,但1已经在第一位了,即1未出现在前面的低位当中,所以只有一个数2 1*2! ;
  第三位是2小于2的数是1,但1在第一位,即1未出现在前面的低位当中,所以有0个数 0*1! ;
  所以比1324小的排列有0*3!+1*2!+0*1!=2个,1324是第三个大数。
其代码实现为:


复制代码
 1 #include <iostream>
 2 using namespace std;
 3 
 4 int Cantor(int *s,int n);  //康托展开,判断给定的排列位于全排列中的第几个
 5 long int fac[]={1,1,2,6,24,120,720,5040,40320,362880}; //表示阶乘运算的结果
 6 //long int fac[]={0!,1!,2!,3!,4!,5!,6!,7!,8!,9!};
 7 
 8 int main(int argc,char *argv)
 9 {
10     int s[4]={2,1,3,4};   //表示排列2134
11     int len=4;        //表示数列中数字数目
12     int index=Cantor(s,len);
13     cout<<index<<endl;
14     return 0;
15 }
16 int Cantor(int *s,int n)
17 {
18     int i,j,num,temp;
19     num=0;
20     for(i=0;i<n;i++)
21     {
22         temp=0;     //temp记录当前数位前面的低数位中小于当前位数上的数字的个数
23         for(j=i+1;j<n;j++)
24             if(s[j]<s[i])
25                 temp++;
26         num+=fac[n-1-i]*temp;  //乘以相应的阶乘
27     }
28     return num;
29 }
复制代码
  如何判断给定一个位置,输出该位置上的数列,康拓展开的逆运算,例如:
  {1,2,3,4,5}的全排列,并且已经从小到大排序完毕,请找出第96个数:
 
   首先用96-1得到95
   用95去除4! 得到3余23,即有3个数比该数位上的数字小,则该数位的数字为4;
   用23去除3! 得到3余5,即有3个数比该数位上的数字小,理应为4,但4已在前面的高位中出现过,所以该数位的数字为5;
   用5去除2!得到2余1,即有2个数比该数位上的数字小,则该数位的数字为3;
   用1去除1!得到1余0,即有1个数比该数位上的数字小,则该数位的数字为2;
   最后一个数只能是1;
   所以这个数是45321
其代码实现:


复制代码
 1 #include <iostream>
 2 using namespace std;
 3 
 4 void CantorReverse(int index,int *p,int n);  //康托展开逆用,判断给定的位置中的排列
 5 long int fac[]={1,1,2,6,24,120,720,5040,40320,362880}; //表示阶乘运算的结果
 6 //long int fac[]={0!,1!,2!,3!,4!,5!,6!,7!,8!,9!};
 7 
 8 int main(int argc,char *argv)
 9 {
10     int len=5; 
11     int *s=(int *)malloc(len*sizeof(int));
12     CantorReverse(96,s,len);  //有数字{12345}组成的所有排列中,求出第96个排列的顺序
13     for(int i=0;i<len;i++)
14         cout<<s[i];
15     cout<<endl;
16     free(s);
17     return 0;
18 }
19 void CantorReverse(int index,int *p,int n)
20 {
21     index--;     //勿丢
22     int i,j;
23     bool hash[10]={0};
24     for(i=0;i<n;i++)
25     {
26         int tmp=index/fac[n-1-i];  //tmp表示有tmp个数字比当前位置上的数字小
27         for(j=0;j<=tmp;j++)
28             if(hash[j]) tmp++;
29         p[i]=tmp+1;
30         hash[tmp]=1; 
31         index%=fac[n-1-i];
32     }
33     return;
34 }


上面网上找的康拓展开的解释


康拓展开逆运算:


#include<stdio.h>


char s[5] = {'0'};
int a[5];
int  fac[100] = {0,1,2,6,24,120,720};
void find(int num, int len);
int main()
{
int n,len;
len = 5;
scanf("%d",&n);
find(n,len);
printf("%s\n",s);
return 0;
}


void find(int num, int len)
{
int i, temp,j,k;
num--;
for(i = 0; i <= len- 1; i++)
{
if(num != 0)
{
temp = num /(fac[len - 1 - i]) + 1;
num = num % (fac[len - 1-i]);
if(a[temp])
temp++;
s[i] = temp + 48;
a[temp] = 1;
}
else
{
k = 1;
while(a[k])
k++;
s[i] = k + 48;


}
}
}


自己尝试:

康拓展开:


#include<stdio.h>


int  fac[100] = {0,1,2,6,24,120,720};


int main()
{
int n, i,num,temp, j, len;
int a[4] = {3,4,1,2};
len = 3;
num = 0;
for(i = 0; i < len; i++)
{
temp =a[i] - 1;
for(j = 0; j < i; j++)
if(a[j] < a[i])
temp--;//temp记录的是比这个数小的且没有在前面的排列出现过;
num += temp *fac[len - i];
printf("t = %d\n",temp);
printf("f = %d, i = %d\n",fac[i], i);
printf("%d\n",num);
}
printf("%d\n",num);
return 0;


}

内容概要:本文系统介绍了算术优化算法(AOA)的基本原理、核心思想及Python实现方法,并通过图像分割的实际案例展示了其应用价值。AOA是一种基于种群的元启发式算法,其核心思想来源于四则运算,利用乘除运算进行全局勘探,加减运算进行局部开发,通过数学优化器加速函数(MOA)和数学优化概率(MOP)动态控制搜索过程,在全局探索与局部开发之间实现平衡。文章详细解析了算法的初始化、勘探与开发阶段的更新策略,并提供了完整的Python代码实现,结合Rastrigin函数进行测试验证。进一步地,以Flask框架搭建前后端分离系统,将AOA应用于图像分割任务,展示了其在实际工程中的可行性与高效性。最后,通过收敛速度、寻优精度等指标评估算法性能,并提出自适应参数调整、模型优化和并行计算等改进策略。; 适合人群:具备一定Python编程基础和优化算法基础知识的高校学生、科研人员及工程技术人员,尤其适合从事人工智能、图像处理、智能优化等领域的从业者;; 使用场景及目标:①理解元启发式算法的设计思想与实现机制;②掌握AOA在函数优化、图像分割等实际问题中的建模与求解方法;③学习如何将优化算法集成到Web系统中实现工程化应用;④为算法性能评估与改进提供实践参考; 阅读建议:建议读者结合代码逐行调试,深入理解算法流程中MOA与MOP的作用机制,尝试在不同测试函数上运行算法以观察性能差异,并可进一步扩展图像分割模块,引入更复杂的预处理或后处理技术以提升分割效果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值