ACM常见题型个人解法

合集下载

Acm竞赛常用算法与数据结构

Acm竞赛常用算法与数据结构

• 每次用堆取出x进行计算,O(mnlogmn)。
28
哈希表(Hash)
• 理论上查找速度最快的数据结构之一 • 缺点: 需要大量的内存 需要构造Key
29
Hash表的实现
• 数组 • 冲突解决法 • 开散列法 • 闭散列法 C++ sgi stl 实现
30
Hash Key的选取
• 数值: • 方法一:直接取余数(一般选取质数M最为除 数) • 方法二:平方取中法,即计算关键值的平方, 2 r 的表 再取中间r位形成一个大小为
7
常见题型
•Dynamic Programming(动 态规划) •Greedy(贪心) •Complete Search(穷举) •Flood Fill (种子填充)
8
常见题型
• Shortest Path (最短路径) • Recursive Search Techniques (回溯) • Minimum Spanning Tree (最小 生成树) • Knapsack(背包)
22
Parity(ceoi99)
• 从整个01序列肯定是无法入手的,因为它 的长度高达109。 • 从范围比较小的n入手。也就是说我们需要 对信息进行一些特殊的处理。 • a b even/odd,那么将元素b指向a-1, 边的权值是even/odd。 • 下面我们由样例来说明一下这个处理方法。
23
11
12
枚举法
• 又叫穷举法,它利用了计算机计算 速度快且准确的特点,是最为朴素 和有效的一种算法。
• 不是办法的办法
• 但有时却是最好的办法
13
Pizza Anyone? (ZOJ 1219)
• 题目大意: 你需要为你和你的朋友们订一个皮萨。 每个朋友都会告诉你他们想和不想放进皮萨 里的东西。 你是否能订一个皮萨,让他满足每个人 至少一个条件。 假设一共有16种东西可以放进皮萨。

acm竞赛试题及答案

acm竞赛试题及答案

acm竞赛试题及答案ACM(Association for Computing Machinery)竞赛是一项全球性计算机科学竞赛,旨在锻炼参赛者的问题解决能力和编程技巧。

每年都有数千名来自不同学校的学生参加这一挑战。

本文将提供一些最近的ACM竞赛试题以及相应的答案,帮助读者了解和学习竞赛题目的类型和解题思路。

1. 问题描述给定一个由N个整数组成的数组A,请编写一个程序,找出数组中两个不同元素的差的最小值。

2. 输入格式- 第一行包含一个整数N,表示数组A的长度。

- 第二行包含N个以空格分隔的整数,表示数组A中的元素。

3. 输出格式输出一个整数,表示数组中两个不同元素的差的最小值。

4. 示例输入:51 52 9 12输出:15. 解题思路该问题可以通过对数组进行排序,并比较相邻两个数的差值来求解。

首先,将数组A进行升序排序。

然后,遍历排序后的数组,依次计算相邻两个数的差值,并记录其中的最小值。

最后,返回这个最小差值即可。

6. 代码实现```pythondef min_difference(nums):nums.sort() # 对数组进行升序排序min_diff = float('inf') # 初始化最小差值为正无穷大for i in range(len(nums)-1):diff = abs(nums[i] - nums[i+1]) # 计算相邻两个数的差值min_diff = min(min_diff, diff) # 更新最小差值return min_diff# 输入处理N = int(input())A = list(map(int, input().split()))# 调用函数并输出结果result = min_difference(A)print(result)```7. 答案解析对给定的数组进行排序后,遍历数组计算相邻两个数的差值,并记录其中的最小值。

上述代码中,首先将数组A进行升序排序,然后使用一个变量`min_diff`来记录最小差值。

ACM常用算法

ACM常用算法

ACM常用算法ACM常考算法ACM小组内部预定函数Ver 2.0 by IcyFenix数学问题:1.精度计算――大数2.精度计算――乘法(大数3.精度计算――乘法(大阶乘5.精度计算――减法9.快速傅立叶变换(FFT)字符串处理:1.字符串替换计算几何:1.叉乘法求任意多边形面积5.射向法判断点是否在多边形内部9.点到线段最短距离数论:1.x的二进制长度5.求解模线性方程组(中国余数定理) 图论:1.Prim算法求最小生成树排序/查找:1.快速排序数据结构:1.顺序队列乘小数)6.任意进制转换10.Ronberg算法计算积分2.字符串查找2.求三角形面积6.判断点是否在线段上10.求两直线的交点2.返回x的二进制表示中从低到高的第i位6.筛法素数产生器2.Dijkstra算法求单源最短路径2.希尔排序2.顺序栈数乘大数)4.精度计算――加法7.最大公约数、最小公倍数8.组合序列11.行列式计算12.求排列组合数3.字符串截取3.两矢量间角度4.两点距离(2D、3D)7.判断两线段是否相交8.判断线段与直线是否相交11.判断一个封闭图形是12.Graham扫描法寻凹集还是凸集找凸包3.模取幂运算4.求解模线性方程7.判断一个数是否素数3.Bellman-ford算法求4.Floyd算法求每对单源最短路径节点间最短路径3.选择法排序4.二分查找3.链表4.链栈ACM常考算法5.二叉树一、数学问题1.精度计算――大数阶乘语法:int result=factorial(int n); 参数:n:n 的阶乘返回阶乘结果的位数值:注意:源程序:本程序直接输出n!的结果,需要返回结果请保留long a[] 需要math.hint factorial(int n){long a[__];int i,j,l,c,m=0,w; a=1;for(i=1;ii++) { c=0;for(j=0;jj++) {a[j]=a[j]*i+c; c=a[j]/__; a[j]=a[j]%__; }if(c0) {m++;a[m]=c;} }w=m*4+log10(a[m])+1;printf(“\n%ld",a[m]);for(i=m-1;ii--) printf("%4.4ld",a[i]);return w; }2.精度计算――乘法(大数乘小数)语法:mult(char c[],char t[],int m); 参数:c[]:被乘数,用字符串表示,位数不限t[]:结果,用字符串表示m:乘数,限定10以内返回null 值:注意:需要string.hACM常考算法源程序:void mult(char c[],char t[],int m) {int i,l,k,flag,add=0; char s; l=strlen(c);for (i=0;ii++)s[l-i-1]=c[i]-'0';for (i=0;ii++) {k=s[i]*m+add;if (k=10) {s[i]=k%10;add=k/10;flag=1;}else {s[i]=k;flag=0;add=0;} }if (flag) {l=i+1;s[i]=add;}else l=i; for (i=0;ii++)t[l-1-i]=s[i]+'0'; t[l]='\0'; }3.精度计算――乘法(大数乘大数)语法:mult(char a[],char b[],char s[]); 参数:a[]:被乘数,用字符串表示,位数不限b[]:乘数,用字符串表示,位数不限t[]:结果,用字符串表示返回null 值:注意:源程序:空间复杂度为o(n^2) 需要string.hvoid mult(char a[],char b[],char s[]) {int i,j,k=0,alen,blen,sum=0,res={0},flag=0; char result;alen=strlen(a);blen=strlen(b);for (i=0;ialen;i++)for (j=0;jblen;j++) res[i][j]=(a[i]-'0')*(b[j]-'0'); for (i=alen-1;ii--) {for (j=blen-1;jj--) sum=sum+res[i+blen-j-1][j]; result[k]=sum%10; k=k+1;ACM常考算法sum=sum/10; }for (i=blen-2;ii--) {for (j=0;jj++) sum=sum+res[i-j][j]; result[k]=sum%10; k=k+1;sum=sum/10; }if (sum!=0) {result[k]=sum;k=k+1;} for (i=0;ii++) result[i]+='0';for (i=k-1;ii--) s[i]=result[k-1-i]; s[k]='\0';while(1) {if (strlen(s)!=strlen(a)s=='0') strcpy(s,s+1); elsebreak; } }4.精度计算――加法语法:add(char a[],char b[],char s[]); 参数:a[]:被乘数,用字符串表示,位数不限b[]:乘数,用字符串表示,位数不限t[]:结果,用字符串表示返回null 值:注意:源程序:空间复杂度为o(n^2) 需要string.hvoid add(char a[],char b[],char back[]) {int i,j,k,up,x,y,z,l; char *c; if (strlen(a)strlen(b)) l=strlen(a)+2;elsel=strlen(b)+2; c=(char *) malloc(l*sizeof(char)); i=strlen(a)-1; j=strlen(b)-1; k=0;up=0;while(i=0||j=0) {if(i0) x='0'; else x=a[i];ACM常考算法if(j0) y='0'; else y=b[j]; z=x-'0'+y-'0'; if(up) z+=1;if(z9) {up=1;z%=10;} else up=0; c[k++]=z+'0'; i--;j--; }if(up) c[k++]='1'; i=0;c[k]='\0';for(k-=1;kk--) back[i++]=c[k]; back[i]='\0'; }5.精度计算――减法语法:sub(char s1[],char s2[],char t[]); 参数:s1[]:被减数,用字符串表示,位数不限s2[]:减数,用字符串表示,位数不限t[]:结果,用字符串表示返回null 值:注意:源程序:默认s1=s2,程序未处理负数情况需要string.hvoid sub(char s1[],char s2[],char t[]) {int i,l2,l1,k;l2=strlen(s2);l1=strlen(s1); t[l1]='\0';l1--;for (i=l2-1;ii--,l1--) {if (s1[l1]-s2[i]=0)t[l1]=s1[l1]-s2[i]+'0'; else {t[l1]=10+s1[l1]-s2[i]+'0'; s1[l1-1]=s1[l1-1]-1; } } k=l1;while(s1[k]0) {s1[k]+=10;s1[k-1]-=1;k--;} while(l1=0) {t[l1]=s1[l1];l1--;} loop:if (t=='0') {ACM常考算法l1=strlen(s1);for (i=0;il1-1;i++) t[i]=t[i+1]; t[l1-1]='\0'; goto loop; }if (strlen(t)==0) {t='0';t='\0';} }6.任意进制转换语法:conversion(char s1[],char s2[],long d1,long d2); 参数:s[]:原进制数字,用字符串表示s2[]:转换结果,用字符串表示d1:原进制数d2:需要转换到的进制数返回null 值:注意:源程序:高于9的位数用大写'A'~'Z'表示,2~16位进制通过验证void conversion(char s[],char s2[],long d1,long d2) {long i,j,t,num; char c; num=0;for (i=0;s[i]!='\0';i++) {if (s[i]='9's[i]='0') t=s[i]-'0';else t=s[i]-'A'+10;num=num*d1+t; } i=0; while(1) {t=num%d2;if (t=9) s2[i]=t+'0';else s2[i]=t+'A'-10; num/=d2;if (num==0)break; i++; }for (j=0;jj++){c=s2[j];s2[j]=s[i-j];s2[i-j]=c;} s2[i+1]='\0'; }7.最大公约数、最小公倍数ACM常考算法语法:resulet=hcf(int a,int b)、result=lcd(int a,int b) 参数:a:int a,求最大公约数或最小公倍数b:int b,求最大公约数或最小公倍数返回返回最大公约数(hcf)或最小公倍数(lcd)值:注意:源程序:lcd 需要连同hcf 使用int hcf(int a,int b) {int r=0; while(b!=0) {r=a%b; a=b; b=r; }return(a); }lcd(int u,int v,int h) {return(u*v/h); }8.组合序列语法:m_of_n(int m,int n1,int m1,int* a,int head) 参数:m:组合数C的上参数n1:组合数C的下参数m1:组合数C的上参数,递归之用*a:1~n的整数序列数组head:头指针返回null 值:注意:源程序:*a需要自行产生初始调用时,m=m1、head=0调用例子:求C(m,n)序列:m_of_n(m,n,m,a,0);ACM常考算法void m_of_n(int m,int n1,int m1,int* a,int head) {int i,t;if(m10 || m1n1)return; if(m1==n1) {for(i=0;ii++) couta[i]' '; // 输出序列cout'\n'; return; }m_of_n(m,n1-1,m1,a,head); // 递归调用t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t; m_of_n(m,n1-1,m1-1,a,head+1); // 再次递归调用t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t; }9.快速傅立叶变换(FFT)语法:kkfft(double pr[],double pi[],int n,int k,double fr[],double fi[],int l,int il); 参数:pr[n]:输入的实部pi[n]:数入的虚部n,k:满足n=2^k fr[n]:输出的实部fi[n]:输出的虚部l:逻辑开关,0 FFT,1 ifFTil:逻辑开关,0 输出按实部/虚部;1 输出按模/幅角返回null 值:注意:源程序:需要math.hvoid kkfft(pr,pi,n,k,fr,fi,l,il)int n,k,l,il;double pr[],pi[],fr[],fi[]; {int it,m,is,i,j,nv,l0;double p,q,s,vr,vi,poddr,poddi; for (it=0; it=n-1; it++) {m=it; is=0;for (i=0; i=k-1; i++){j=m/2; is=2*is+(m-2*j); m=j;} fr[it]=pr[is]; fi[it]=pi[is]; }pr=1.0; pi=0.0; p=6.__-__6/(1.0*n);pr=cos(p); pi=-sin(p);ACM常考算法if (l!=0) pi=-pi; for (i=2; i=n-1; i++) {p=pr[i-1]*pr; q=pi[i-1]*pi;s=(pr[i-1]+pi[i-1])*(pr+pi); pr[i]=p-q; pi[i]=s-p-q; }for (it=0; it=n-2; it=it+2) {vr=fr[it]; vi=fi[it];fr[it]=vr+fr[it+1]; fi[it]=vi+fi[it+1];fr[it+1]=vr-fr[it+1]; fi[it+1]=vi-fi[it+1]; }m=n/2; nv=2;for (l0=k-2; l0 l0--) {m=m/2; nv=2*nv;for (it=0; it=(m-1)*nv; it=it+nv) for (j=0; j=(nv/2)-1; j++) {p=pr[m*j]*fr[it+j+nv/2]; q=pi[m*j]*fi[it+j+nv/2]; s=pr[m*j]+pi[m*j];s=s*(fr[it+j+nv/2]+fi[it+j+nv/2]); poddr=p-q; poddi=s-p-q;fr[it+j+nv/2]=fr[it+j]-poddr; fi[it+j+nv/2]=fi[it+j]-poddi;fr[it+j]=fr[it+j]+poddr; fi[it+j]=fi[it+j]+poddi; } }if (l!=0)for (i=0; i=n-1; i++) {fr[i]=fr[i]/(1.0*n); fi[i]=fi[i]/(1.0*n); } if (il!=0)for (i=0; i=n-1; i++) {pr[i]=sqrt(fr[i]*fr[i]+fi[i]*fi[i]); if (fabs(fr[i])0.000001*fabs(fi[i])) {if ((fi[i]*fr[i])0) pi[i]=90.0; else pi[i]=-90.0; } elsepi[i]=atan(fi[i]/fr[i])*360.0/6.__-__6; } return; }10.Ronberg算法计算积分语法:result=integral(double a,double b);ACM常考算法参数:a:积分上限b:积分下限function积分函数f:返回值:f在(a,b)之间的积分值注意:源程序:function f(x)需要自行修改,程序中用的是sina(x)/x 需要math.h 默认精度要求是1e-5double f(double x) {return sin(x)/x; //在这里插入被积函数}double integral(double a,double b) {double h=b-a;double t1=(1+f(b))*h/2.0; int k=1;double r1,r2,s1,s2,c1,c2,t2; loop:double s=0.0;double x=a+h/2.0; while(xb) {s+=f(x); x+=h; }t2=(t1+h*s)/2.0; s2=t2+(t2-t1)/3.0; if(k==1) {k++;h/=2.0;t1=t2;s1=s2; goto loop; }c2=s2+(s2-s1)/15.0; if(k==2){c1=c2;k++;h/=2.0; t1=t2;s1=s2; goto loop; }r2=c2+(c2-c1)/63.0; if(k==3){r1=r2; c1=c2;k++; h/=2.0;t1=t2;s1=s2; goto loop; }while(fabs(1-r1/r2)1e-5){ r1=r2;c1=c2;k++; h/=2.0;ACM常考算法t1=t2;s1=s2; goto loop; }return r2; }11.行列式计算语法:result=js(int s[][],int n) 参数:s[][]:行列式存储数组n:行列式维数,递归用返回行列式值值:注意:源程序:函数中常数N为行列式维度,需自行定义int js(s,n)int s[][N],n; {int z,j,k,r,total=0; int b[N][N];/*b[N][N]用于存放,在矩阵s[N][N]中元素s的余子式*/if(n2) {for(z=0;zz++) {for(j=0;jj++)for(k=0;kk++)if(k=z) b[j][k]=s[j+1][k+1]; else b[j][k]=s[j+1][k];if(z%2==0) r=s[z]*js(b,n-1); /*递归调用*/ else r=(-1)*s[z]*js(b,n-1); total=total+r; } }else if(n==2)total=s*s-s*s; return total; }12.求排列组合数语法:result=P(long n,long m); / result=long C(long n,long m); 参数:m:排列组合的上系数n:排列组合的下系数返回排列组合数ACM常考算法值:注意:源程序:符合数学规则:m=nlong P(long n,long m) {long p=1; while(m!=0){p*=n;n--;m--;} return p; }long C(long n,long m) {long i,c=1; i=m;while(i!=0){c*=n;n--;i--;} while(m!=0) {c/=m;m--;} return c; }二、字符串处理1.字符串替换语法:replace(char str[],char key[],char swap[]); 参数:str[]:在此源字符串进行替换操作key[]:被替换的字符串,不能为空串swap[]替换的字符串,可以为空串,为空串表示在源字符中删除key[] :返回null 值:注意:源程序:默认str[]长度小于1000,如否,重新设定设定tmp大小需要string.hvoid replace(char str[],char key[],char swap[]) {int l1,l2,l3,i,j,flag; char tmp; l1=strlen(str); l2=strlen(key);l3=strlen(swap);for (i=0;i=l1-l2;i++)ACM常考算法{flag=1;for (j=0;jj++)if (str[i+j]!=key[j]) {flag=0;break;} if (flag) {strcpy(tmp,str);strcpy(tmp[i],swap);strcpy(tmp[i+l3],str[i+l2]); strcpy(str,tmp); i+=l3-1;l1=strlen(str); } } }2.字符串查找语法:result=strfind(char str[],char key[]); 参数:str[]:在此源字符串进行查找操作key[]:被查找的字符串,不能为空串返回如果查找成功,返回key在str中第一次出现的位置,否则返回-1 值:注意:源程序:需要string.hint strfind(char str[],char key[]) {int l1,l2,i,j,flag; l1=strlen(str); l2=strlen(key);for (i=0;i=l1-l2;i++) {flag=1;for (j=0;jj++)if (str[i+j]!=key[j]) {flag=0;break;} if (flag)return i; }return -1; }3.字符串截取语法:mid(char str[],int start,int len,char strback[]) 参数:str[]:操作的目标字符串start:从第start个字符串开始,截取长度为len的字符ACM常考算法len:从第start个字符串开始,截取长度为len的字符strback[ 截取的到的字符]:返回值:0:超出字符串长度,截取失败;1:截取成功注意:需要string.h源程序:int mid(char str[],int start,int len,char strback[]) {int l,i,k=0; l=strlen(str);if (start+lenl)return 0; for (i=start;istart+len;i++) strback[k++]=str[i]; strback[k]='\0'; return 1; }三、计算几何1.叉乘法求任意多边形面积语法:result=polygonarea(Point *polygon,int N); 参数:*polyg多变形顶点数组on:N:多边形顶点数目返回多边形面积值:注意:源程序:支持任意多边形,凹、凸皆可多边形顶点输入时按顺时针顺序排列typedef struct { double x,y; } Point;double polygonarea(Point *polygon,int N) {int i,j;double area = 0;for (i=0;ii++) { j = (i + 1) % N;area += polygon[i].x * polygon[j].y; area -= polygon[i].y *polygon[j].x; }ACM常考算法area /= 2;return(area 0 ? -area : area); }2.求三角形面积语法:result=area3(float x1,float y1,float x2,float y2,float x3,float y3); 参数:x1~3:三角形3个顶点x坐标y1~3:三角形3个顶点y坐标返回三角形面积值:注意:源程序:需要math.hfloat area3(float x1,float y1,float x2,float y2,float x3,float y3) {float a,b,c,p,s;a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); b=sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3)); c=sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2)); p=(a+b+c)/2;s=sqrt(p*(p-a)*(p-b)*(p-c)); return s; }3.两矢量间角度语法:result=angle(double x1,double y1,double x2,double y2); 参数:x/y1~两矢量的坐标2:返回两的角度矢量值:注意:源程序:返回角度为弧度制,并且以逆时针方向为正方向需要math.h#define PI 3.__-__double angle(double x1,double y1,double x2,double y2) {ACM常考算法double dtheta,theta1,theta2; theta1 = atan2(y1,x1); theta2 =atan2(y2,x2); dtheta = theta2 - theta1; while (dtheta PI) dtheta -= PI*2; while (dtheta -PI) dtheta += PI*2; return(dtheta); }4.两点距离(2D、3D)语法:result=distance_2d(float x1,float x2,float y1,float y2); 参数:x/y/z1各点的x、y、z坐标~2:返回两点之间的距离值:注意:源程序:需要math.hfloat distance_2d(float x1,float x2,float y1,float y2) {return(sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))); }float distance_3d(float x1,float x2,float y1,float y2,float z1,float z2) { return(sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2))); }5.射向法判断点是否在多边形内部语法:result=insidepolygon(Point *polygon,int N,Point p); 参数:*polyg多边形顶点数组on:N:多边形顶点个数p:被判断点返回0:点在多边形内部;1:点在多边形外部值:注意:若p点在多边形顶点或者边上,返回值不确定,需另行判断ACM常考算法源程序:需要math.h#define MIN(x,y) (x y ? x : y)#define MAX(x,y) (x y ? x : y) typedef struct { double x,y; } Point;int insidepolygon(Point *polygon,int N,Point p) {int counter = 0; int i;double xinters; Point p1,p2;p1 = polygon;for (i=1;ii++) { p2 = polygon[i % N];if (p.y MIN(p1.y,p2.y)) {if (p.y = MAX(p1.y,p2.y)) {if (p.x = MAX(p1.x,p2.x)) { if (p1.y != p2.y) { xinters =(p.y-p1.y)*(p2.x-p1.x)/(p2.y-p1.y)+p1.x;if (p1.x == p2.x || p.x = xinters) counter++; } } } }p1 = p2; }if (counter % 2 == 0) return(__); elsereturn(INSIDE); }6.判断点是否在线段上语法:result=Pointonline(Point p1,Point p2,Point p); 参数:p1、p2:线段的两个端点p:被判断点返回0:点在不在线段上;1:点在线段上值:注意:源程若p线段端点上返回1 需要math.hACM常考算法序:#define MIN(x,y) (x y ? x : y)#define MAX(x,y) (x y ? x : y) typedef struct {double x,y; } Point;int FC(double x1,double x2) {if (x1-x20.000002x1-x2-0.000002)return 1;else return 0; }int Pointonline(Point p1,Point p2,Point p) {double x1,y1,x2,y2; x1=p.x-p1.x; x2=p2.x-p1.x; y1=p.y-p1.y; y2=p2.y-p1.y;if (FC(x1*y2-x2*y1,0)==0)return 0;if ((MIN(p1.x,p2.x)=p.xp.x=MAX(p1.x,p2.x))(MIN(p1.y,p2.y)=p.yp.y=MAX(p1.y,p2.y))) return 1;else return 0; }7.判断两线段是否相交语法:result=sectintersect(Point p1,Point p2,Point p3,Point p4); 参数:p1~两条线段的四个端点4:返回0:两线段不相交;1:两线段相交;2两线段首尾相接值:注意:源程序:p1!=p2;p3!=p4;#define MIN(x,y) (x y ? x : y)#define MAX(x,y) (x y ? x : y) typedef struct { double x,y; } Point;int lineintersect(Point p1,Point p2,Point p3,Point p4) {Point tp1,tp2,tp3; if((p1.x==p3.xp1.y==p3.y)||(p1.x==p4.xp1.y==p4.y)||(p2.x==p3.xp2.y==p3.y )||(p2.x==p4.xp2.y==p4.y)) return 2; //快速排斥试验if((MIN(p1.x,p2.x)p3.xp3.xMAX(p1.x,p2.x)MIN(p1.y,p2.y)p3.yMAX(p1.y,p2.y))|| ACM常考算法(MIN(p1.x,p2.x)p4.xp3.xMAX(p1.x,p2.x)MIN(p1.y,p2.y)p3.yMAX(p1.y,p2.y))) ; else return 0;//跨立试验tp1.x=p1.x-p3.x; tp1.y=p1.y-p3.y; tp2.x=p4.x-p3.x; tp2.y=p4.y-p3.y; tp3.x=p2.x-p3.x; tp3.y=p2.y-p3.y;if ((tp1.__tp2.y-tp1.y*tp2.x)*(tp2.__tp3.y-tp2.y*tp3.x)=0)return 1;else return 0; }8.判断线段与直线是否相交语法:result=lineintersect(Point p1,Point p2,Point p3,Point p4); 参数:p1、p2:线段的两个端点p3、p4:直线上的两个点返回0:线段直线不相交;1:线段和直线相交值:注意:源程序:如线段在直线上,返回1typedef struct { double x,y; } Point;int lineintersect(Point p1,Point p2,Point p3,Point p4) {Point tp1,tp2,tp3; tp1.x=p1.x-p3.x; tp1.y=p1.y-p3.y; tp2.x=p4.x-p3.x; tp2.y=p4.y-p3.y; tp3.x=p2.x-p3.x; tp3.y=p2.y-p3.y;if ((tp1.__tp2.y-tp1.y*tp2.x)*(tp2.__tp3.y-tp2.y*tp3.x)=0)return 1;else return 0; }9.点到线段最短距离语法:result=mindistance(Point p1,Point p2,Point q); 参数:p1、线段的两个端点p2:ACM常考算法q:判断点返回点q到线段p1p2的距离值:注意:源程序:需要math.h#define MIN(x,y) (x y ? x : y)#define MAX(x,y) (x y ? x : y) typedef struct { double x,y; } Point;double mindistance(Point p1,Point p2,Point q) {int flag=1; double k; Point s;if (p1.x==p2.x) {s.x=p1.x;s.y=q.y;flag=0;} if (p1.y==p2.y){s.x=q.x;s.y=p1.y;flag=0;} if (flag) {k=(p2.y-p1.y)/(p2.x-p1.x);s.x=(k*k*p1.x+k*(q.y-p1.y)+q.x)/(k*k+1); s.y=k*(s.x-p1.x)+p1.y; }if (MIN(p1.x,p2.x)=s.xs.x=MAX(p1.x,p2.x))return sqrt((q.x-s.x)*(q.x-s.x)+(q.y-s.y)*(q.y-s.y)); elsereturnMIN(sqrt((q.x-p1.x)*(q.x-p1.x)+(q.y-p1.y)*(q.y-p1.y)),sqrt((q.x-p2.x)*(q.x-p2.x)+(q.y-p2.y)*(q.y-p2.y))); }10.求两直线的交点语法:result=mindistance(Point p1,Point p2,Point q); 参数:p1~直线上不相同的两点p4:*p:通过指针返回结果返回1:两直线相交;2:两直线平行值:注意:源程序:如需要判断两线段交点,检验k和对应k1(注释中)的值是否在0~1之间,用在0~1之间的那个求交点ACM常考算法typedef struct { double x,y; } Point;int linecorss(Point p1,Point p2,Point p3,Point p4,Point *p) {double k; //同一直线if ((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x)==0(p2.x-p1.x)*(p1.y-p3.y)-(p2.y-p1.y)*(p1.x-p3.x)==0) return 2; //平行,不同一直线if ((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y)==0) return 0;k=((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y));//k1=((p2.x-p1.x)*(p1.y-p3.y)-(p2.y-p1.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y)); (*p).x=p1.x+k*(p2.x-p1.x);(*p).y=p1.y+k*(p2.y-p1.y); return 1;//有交点}11.判断一个封闭图形是凹集还是凸集语法:result=convex(Point *p,int n); 参数:*p:封闭曲线顶点数组n:封闭曲线顶点个数返回1:凸集;-1:凹集;0:曲线不符合要求无法计算值:注意:源程序:默认曲线为简单曲线:无交叉、无圈typedef struct { double x,y; } Point;。

acm构造题

acm构造题

acm构造题
当谈到构造题时,有许多不同类型的ACM构造问题。

以下是一些常见的ACM构造题目类型和解决方法:
1.排列组合构造:这类问题通常要求你构造一个满足某种条件的排列或组合。

解决这类问题的关键是理解条件并找到一种满足条件的构造方法。

可以使用递归、迭代或其他数学技巧来解决这类问题。

2.图论构造:这类问题涉及到构建满足某些图论性质的图。

常见的图论构造问题包括树的构造、连通图的构造、二分图的构造等。

解决这类问题通常需要理解图论的基本概念和性质,并使用合适的算法进行构造。

3.数据结构构造:这类问题要求你构造一个满足某种数据结构性质的数据结构。

例如,构造一个满足平衡二叉搜索树性质的树,或者构造一个满足堆性质的数组。

解决这类问题通常需要对特定数据结构的性质和操作进行了解,并设计相应的构造方法。

4.数学构造:这类问题要求你构造一个满足某种数学性质的对象。

例如,构造一组满足特定方程的整数,或者构造一种满足特定性质的数列。

解决这类问题通常需要运用数学知识和技巧,并找到合适的构造方法。

对于ACM构造题目,关键是理解问题的要求和条件,并设计一个满足条件的构造方法。

可以根据问题的性质选择适当的算法、数据结构或数学技巧来解决问题。

在解题过程中,需要注意时间复杂度和空间复杂度的控制,以确保算法的效率和正
确性。

另外,多进行思维训练和练习,熟悉不同类型的构造问题,能够提高解决问题的能力。

ACM程序设计算法讲解

ACM程序设计算法讲解

目录1.河内之塔 .............................................................................................................. 错误!未定义书签。

Gossip: 费式数列 ................................................................................................. 错误!未定义书签。

3.巴斯卡三角形 .................................................. 错误!未定义书签。

Gossip: 三色棋.................................................. 错误!未定义书签。

Gossip: 老鼠走迷官(一)........................................ 错误!未定义书签。

Gossip: 老鼠走迷官(二)........................................ 错误!未定义书签。

Gossip: 骑士走棋盘.............................................. 错误!未定义书签。

Gossip: 八皇后.................................................. 错误!未定义书签。

Gossip: 八枚银币................................................ 错误!未定义书签。

Gossip: 生命游戏................................................ 错误!未定义书签。

Gossip: 字串核对................................................ 错误!未定义书签。

acm数学竞赛试题及答案

acm数学竞赛试题及答案

acm数学竞赛试题及答案# 题目一:数列问题问题描述:给定一个数列 \( a_1, a_2, a_3, \ldots, a_n \),数列中每个元素都是正整数,且满足 \( a_i = a_{i-1} + a_{i-2} \) 对于所有\( i \geq 3 \)。

如果 \( a_1 = 1 \) 且 \( a_2 = 1 \),请找出数列的第 \( n \) 项。

解答:根据题意,这是一个斐波那契数列。

第 \( n \) 项的值可以通过递归关系计算得出。

对于 \( n \) 的值,可以使用以下递归公式:\[ a_n = a_{n-1} + a_{n-2} \]其中,\( a_1 = 1 \) 和 \( a_2 = 1 \)。

因此,数列的前几项为 1, 1, 2, 3, 5, 8, 13, 21, ...。

对于任意的 \( n \),可以通过递归或动态规划方法计算出 \( a_n \)。

# 题目二:组合问题问题描述:从 \( n \) 个不同的元素中选择 \( k \) 个元素的所有可能组合的个数是多少?解答:这个问题可以通过组合数学中的二项式系数来解决。

从 \( n \) 个不同元素中选择 \( k \) 个元素的组合数 \( C(n, k) \) 可以用以下公式计算:\[ C(n, k) = \frac{n!}{k!(n-k)!} \]其中,\( n! \) 表示 \( n \) 的阶乘。

# 题目三:几何问题问题描述:在一个直角坐标系中,给定三个点 \( A(x_1, y_1) \),\( B(x_2, y_2) \) 和 \( C(x_3, y_3) \)。

如果 \( \overrightarrow{AB} \) 和 \( \overrightarrow{AC} \) 是垂直的,求证 \( A \) 是直角三角形 \( ABC \) 的直角顶点。

解答:如果 \( \overrightarrow{AB} \) 和 \( \overrightarrow{AC} \) 垂直,那么它们的数量积(点积)应该为零。

ACM常用算法

ACM常用算法

ACM常用算法1)递推求解:首先,确认:能否容易的得到简单情况的解;然后,假设:规模为N-1的情况已经得到解决;最后,重点分析:当规模扩大到N时,如何枚举出所有的情况,并且要确保对于每一种子情况都能用已经得到的数据解决。

例题1在一个平面上有一个圆和n条直线,这些直线中每一条在圆内同其他直线相交,假设没有3条直线相交于一点,试问这些直线将圆分成多少区域。

分析F(1)=2;F(n) = F(n-1)+n;化简后为F(n) = n(n+1)/2 +1;例题2 平面上有n条折线,问这些折线最多能将平面分割成多少块?分析把折线当作两天直线相交然后再减去交集延伸部分。

F= 2n ( 2n + 1 ) / 2 + 1 - 2n;2)贪心算法:在对问题求解时,总是作出在当前看来是最好的选择。

也就是说,不从整体上加以考虑,它所作出的仅仅是在某种意义上的局部最优解(是否是全局最优,需要证明)。

贪心算法的基本步骤包括1、从问题的某个初始解出发。

2、采用循环语句,当可以向求解目标前进一步时,就根据局部最优策略,得到一个部分解,缩小问题的范围或规模。

3、将所有部分解综合起来,得到问题的最终解。

例题1已知N个事件的发生时刻和结束时刻(见下表,表中事件已按结束时刻升序排序)。

一些在时间上没有重叠的事件,可以构成一个事件序列,如事件{2,8,10}。

事件序列包含的事件数目,称为该事件序列的长度。

请编程找出一个最长的事件序列。

分析不妨用Begin[i]和End[i]表示事件i的开始时刻和结束时刻。

则原题的要求就是找一个最长的序列a1<a2<…<an,满足:Begin[a1]<End[a1]<=…<=Begin[an]<End[an];可以证明,如果在可能的事件a1<a2<…<an中选取在时间上不重叠的最长序列,那么一定存在一个包含a1(结束最早)的最长序列。

ACM常见算法

ACM常见算法

ACM常见算法ACM算法⼀、数论算法 1.求两数的最⼤公约数 2.求两数的最⼩公倍数 3.素数的求法 A.⼩范围内判断⼀个数是否为质数: B.判断longint范围内的数是否为素数(包含求50000以内的素数表):⼆、图论算法1.最⼩⽣成树A.Prim算法:B.Kruskal算法:(贪⼼) 按权值递增顺序删去图中的边,若不形成回路则将此边加⼊最⼩⽣成树。

2.最短路径 A.标号法求解单源点最短路径: B.Floyed算法求解所有顶点对之间的最短路径: C. Dijkstra 算法:3.计算图的传递闭包4.⽆向图的连通分量 A.深度优先 B 宽度优先(种⼦染⾊法)5.关键路径⼏个定义:顶点1为源点,n为汇点。

a. 顶点事件最早发⽣时间Ve[j], Ve [j] = max{ Ve [j] + w[I,j] },其中Ve (1) = 0; b. 顶点事件最晚发⽣时间 Vl[j], Vl [j] = min{ Vl[j] – w[I,j] },其中 Vl(n) = Ve(n); c. 边活动最早开始时间 Ee[I], 若边I由<j,k>表⽰,则Ee[I] = Ve[j]; d. 边活动最晚开始时间 El[I], 若边I由<j,k>表⽰,则El[I] = Vl[k] – w[j,k]; 若 Ee[j] = El[j] ,则活动j为关键活动,由关键活动组成的路径为关键路径。

求解⽅法: a. 从源点起topsort,判断是否有回路并计算Ve; b. 从汇点起topsort,求Vl; c. 算Ee 和 El;6.拓扑排序找⼊度为0的点,删去与其相连的所有边,不断重复这⼀过程。

例寻找⼀数列,其中任意连续p项之和为正,任意q 项之和为负,若不存在则输出NO.7.回路问题 Euler回路(DFS) 定义:经过图的每条边仅⼀次的回路。

(充要条件:图连同且⽆奇点) Hamilton回路定义:经过图的每个顶点仅⼀次的回路。

acm基础试题及答案

acm基础试题及答案

acm基础试题及答案1. 题目:给定一个整数数组,请找出数组中第二大的数。

答案:我们可以使用排序的方法,将数组从小到大排序,然后数组中的倒数第二个数就是第二大的数。

或者使用一次遍历的方法,首先初始化两个变量,一个用来存储最大值,一个用来存储第二大的值。

遍历数组,每次比较当前元素与最大值,如果当前元素大于最大值,则更新第二大的值为最大值,并将当前元素赋给最大值;如果当前元素小于最大值但大于第二大的值,则更新第二大的值。

2. 题目:实现一个函数,计算一个字符串中字符出现的次数。

答案:可以使用哈希表来实现,遍历字符串中的每个字符,将其作为键值对存储在哈希表中,键是字符,值是该字符出现的次数。

遍历结束后,哈希表中存储的就是每个字符出现的次数。

3. 题目:给定一个链表,删除链表的倒数第n个节点,并且返回新的链表头节点。

答案:可以使用双指针的方法,首先初始化两个指针,都指向链表的头节点。

然后移动第一个指针,移动n步,此时第一个指针指向倒数第n个节点的前一个节点。

接着同时移动两个指针,直到第一个指针到达链表的末尾,此时第二个指针指向的节点就是需要删除的节点的前一个节点。

然后更新第二个指针的next指针,使其指向第二个指针的next节点的next节点,最后返回链表的头节点。

4. 题目:编写一个函数,判断一个整数是否是回文数。

回文数是指正序和倒序读都一样的数。

答案:首先将整数转换为字符串,然后使用双指针的方法,一个指针从字符串的开始位置,一个指针从字符串的结束位置,向中间移动。

如果两个指针指向的字符不相等,则该整数不是回文数。

如果遍历结束后没有发现不相等的字符,则该整数是回文数。

5. 题目:给定一个字符串,找出其中不含有重复字符的最长子串的长度。

答案:可以使用滑动窗口的方法,维护一个哈希表记录窗口内字符的出现情况,以及一个变量记录不含有重复字符的最长子串的长度。

遍历字符串,每次移动窗口的右端点,如果当前字符不在窗口内,则更新最长子串的长度,并将字符添加到哈希表中。

ACM常见题型题解

ACM常见题型题解

大部分题目都来源于周涵学弟,感谢他的成果,希望大家不断a题,提升自己的能力,都能在校赛上取得好的成绩。

这次比赛很多童鞋都做的很好,不过通过做题也能反映出一些问题。

第一,读题。

很多童鞋交了发现自己的数据爆值,很多时候是因为没有好好读题。

int , long, long long 的范围应该都知道,如果只是因为没有好好读题而出错,这是毫无意义的罚时,所以一定好好好读题,看清数据范围。

第二,跟榜。

在正式的比赛中题目的难度并不是按照ABCD来排列的,简单的题目可能在中间,在最后,所以不要死一道题,而是看题目的通过人数,这是判断题目难度的最好方法,就是跟榜。

第三,扩充自己的知识面。

很多题目用你现有的知识可能很难做出来,但是用一些语言自带的函数或者容器就能简单的做出来了。

这就需要不断学习,多多接受一些新的东西并用到题目当中,会有很好的收获的。

还发现了一些同学有抄袭现象,在正式比赛中所有的题目都是原创的,并且不可以上网寻求帮助,只能带纸质材料。

所以还是珍惜每一次做题的机会,认真的去对待吧。

A:本道题目需要注意1<=n<=1000,而1既不是素数也不是合数,2是最小的素数B:方法采用辗转相除法求的最大公约数,最小公倍数采用:给定的两数之积除以最大公约数。

C:字符串比较大小问题,在C语言中可以调用头文件<string.h>中的strcmp函数直接进行比较。

字符串的取缔符号为%s。

D:此题为排序题,可以采用冒泡排序法,在C++直接有sort排序函数,可以直接调用。

E:学一下结构体排序的方法,顺便自学一波stirng类型F:斐波那契数列采用递归计算法,应题目要求进行取余(因为在计算过程中可能为出现溢出)G:矩阵采用二位数组输入模式,根据二位数组索引值,得出计算规律。

需要注意的是:可能出现10的10次方,所以不要用int。

H:对于每一个点遍历一遍这个点周围的点,然后开一个数组记录下来就好了,搜索的基本运用I:此题重点在于格式和源码中的if语句。

bfs acm竞赛题解

bfs acm竞赛题解

BFS(广度优先搜索)是一种常用的算法,在ACM竞赛中经常出现。

以下是一个BFS的ACM竞赛题解的例子:
题目:农夫知道一头牛的位置,想要抓住它。

农夫和牛都于数轴上,农夫起始位于点N(0<=N<=100000),牛位于点K(0<=K<=100000)。

最少要花多少时间才能抓住牛?
思路:
建立结构体,将牛的位置now和时间time放在一起。

建立一个数组来记录农夫走过的位置。

将结构体放入队列中,用结构体建立next和now(农夫的现在和接下来的位置)。

在农夫每一次行动的最终结果与牛所在的位置做对比,如果now.x与m相等,就说明农夫找到了牛,根据BFS广搜的特性必定是最短路径。

ACM模式归纳总结

ACM模式归纳总结

ACM模式归纳总结ACM竞赛是一项专注于算法和编程的比赛,旨在锻炼参赛者的解决问题的能力和创新思维。

在参加ACM竞赛的过程中,我逐渐领悟到一些常见的解题模式,这些模式可以帮助选手更好地解决问题,提高算法设计和优化能力。

本文将对我在ACM竞赛中使用的一些常见模式进行归纳和总结,希望对学习和参与ACM竞赛的同学有所帮助。

模式一:贪心算法贪心算法是一种直观简单的算法思想,通常在需要做出一系列选择并且每次选择最优解时使用。

关键点是每一步都选择当前最好的解,而不考虑全局最优。

在ACM竞赛中,贪心算法常用于优化问题、调度问题和区间问题等。

举例来说,在解决约束有限的任务调度问题时,可以使用贪心算法找到最佳的任务执行顺序。

模式二:动态规划动态规划是一种基于分治策略的算法思想,通常用于求解最优化问题。

关键点是将复杂问题分解为重叠子问题,并通过对子问题的求解得到全局最优解。

在ACM竞赛中,动态规划常用于解决最长公共子序列、背包问题和字符串编辑距离等。

举例来说,在解决最长递增子序列问题时,可以使用动态规划记录每个位置的最长递增子序列长度,并不断更新得到最终结果。

模式三:搜索算法搜索算法是一种通过遍历问题的解空间来寻找最优解的算法思想。

关键点是遵循规则进行搜索,并逐步找到满足条件的解。

在ACM竞赛中,搜索算法常用于解决全排列、图的遍历和状态空间搜索等问题。

举例来说,在解决图的最短路径问题时,可以使用广度优先搜索或者迪杰斯特拉算法找到最短路径。

模式四:图论算法图论算法是一种研究图的理论和应用的算法思想,用于解决与图相关的问题。

关键点是通过节点和边之间的关系来表示问题,并使用图的性质和算法求解。

在ACM竞赛中,图论算法常用于解决最小生成树、最短路径和网络流等问题。

举例来说,在解决最小生成树问题时,可以使用克鲁斯卡尔算法或者普里姆算法找到最小生成树。

模式五:位运算位运算是一种对二进制数进行操作的算法思想,常用于优化和加速计算过程。

acm 二分查找题型

acm 二分查找题型

acm二分查找题型
在ACM竞赛中,二分查找是一种常见且重要的算法,用于在有序数组或有序数据集中查找特定元素。

以下是一些常见的ACM二分查找题型及解题思路:
1.普通二分查找:
-题型描述:在有序数组中查找某个特定元素的位置。

-解题思路:通过比较中间元素与目标元素的大小关系,不断缩小查找范围,直到找到目标元素或确认不存在。

2.查找第一个等于目标值的元素:
-题型描述:在有序数组中找到第一个等于给定值的元素。

-解题思路:在普通二分查找基础上,当找到目标值时,继续向左搜索,直到找到第一个等于目标值的元素。

3.查找最后一个等于目标值的元素:
-题型描述:在有序数组中找到最后一个等于给定值的元素。

-解题思路:在普通二分查找基础上,当找到目标值时,继续向右搜索,直到找到最后一个等于目标值的元素。

4.查找第一个大于等于目标值的元素:
-题型描述:在有序数组中找到第一个大于等于给定值的元素。

-解题思路:在普通二分查找基础上,当找到目标值时,继续向左搜索,直到找到第一个大于等于目标值的元素。

5.查找最后一个小于等于目标值的元素:
-题型描述:在有序数组中找到最后一个小于等于给定值的元素。

-解题思路:在普通二分查找基础上,当找到目标值时,继续向右搜索,直到找到最后一个小于等于目标值的元素。

这些题型是二分查找在ACM竞赛中常见的应用场景。

在解题时,需要根据具体问题要求调整二分查找的边界条件和终止条件,以确保得到正确的答案。

ACM常见题型个人解法

ACM常见题型个人解法

求最值时间限制(普通/Java) : 1000 MS/3000 MS运行内存限制: 65536 KByte总提交: 9915 测试通过: 2804比赛描述给定N个整数(1<=N<=100),求出这N个数中的最大值,最小值。

输入多组数据,第一行为一个整数N,第二行为N个不超过100的正整数,用空格隔开。

输出对每组数据输出一行,包含两个整数,用一个空格隔开,分别表示N个数中的最大值和最小值样例输入54 6 7 3 144 35 1样例输出7 15 1#include <stdio.h>int main(){int str[101];int i,n;for(;scanf("%d",&n)==1;){int max=-1;int min=101;if(0<=n&&n<=100){for(i=0;i<n;i++){scanf("%d",&str[i]);max=max>str[i]?max:str[i];min=min<str[i]?min:str[i];}}printf("%d %d\n",max,min);}return 0;}斐波那契数列时间限制(普通/Java) : 1000 MS/10000 MS运行内存限制: 65536 KByte总提交: 6917 测试通过: 2394比赛描述在数学上,斐波那契数列(Fibonacci Sequence),是以递归的方法来定义:F= 0= 1F1F n = F n - 1 + F n - 2用文字来说,就是斐波那契数列由0和1开始,之后的斐波那契数就由之前的两数相加。

首几个斐波那契数是:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946,………………特别指出:0不是第一项,而是第零项。

ACM常用算法及其相应的练习题

ACM常用算法及其相应的练习题

ACM常用算法及其相应的练习题2007-12-03 23:48OJ上的一些水题(可用来练手和增加自信)(poj3299,poj2159,poj2739,poj1083,poj2262,poj1503,poj3006,poj2255,poj3 094)初期:一.基本算法:(1)枚举. (poj1753,poj2965)(2)贪心(poj1328,poj2109,poj2586)(3)递归和分治法.(4)递推.(5)构造法.(poj3295)(6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)二.图算法:(1)图的深度优先遍历和广度优先遍历.(2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)(poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)(3)最小生成树算法(prim,kruskal)(poj1789,poj2485,poj1258,poj3026)(4)拓扑排序 (poj1094)(5)二分图的最大匹配 (匈牙利算法) (poj3041,poj3020)(6)最大流的增广路算法(KM算法). (poj1459,poj3436)三.数据结构.(1)串 (poj1035,poj3080,poj1936)(2)排序(快排、归并排(与逆序数有关)、堆排) (poj2388,poj2299)(3)简单并查集的应用.(4)哈希表和二分查找等高效查找法(数的Hash,串的Hash)(poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)(5)哈夫曼树(poj3253)(6)堆(7)trie树(静态建树、动态建树) (poj2513)四.简单搜索(1)深度优先搜索 (poj2488,poj3083,poj3009,poj1321,poj2251)(2)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)五.动态规划(1)背包问题. (poj1837,poj1276)(2)型如下表的简单DP(可参考lrj的书 page149):1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列)(poj3176,poj1080,poj1159)3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)六.数学(1)组合数学:1.加法原理和乘法原理.2.排列组合.3.递推关系.(POJ3252,poj1850,poj1019,poj1942)(2)数论.1.素数与整除问题2.进制位.3.同余模运算.(poj2635, poj3292,poj1845,poj2115)(3)计算方法.1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)七.计算几何学.(1)几何公式.(2)叉积和点积的运用(如线段相交的判定,点到线段的距离等).(poj2031,poj1039)(3)多边型的简单算法(求面积)和相关判定(点在多边型内,多边型是否相交)(poj1408,poj1584)(4)凸包. (poj2187,poj1113)中级:一.基本算法:(1)C++的标准模版库的应用. (poj3096,poj3007)(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)二.图算法:(1)差分约束系统的建立和求解. (poj1201,poj2983)(2)最小费用最大流(poj2516,poj2516,poj2195)(3)双连通分量(poj2942)(4)强连通分支及其缩点.(poj2186)(5)图的割边和割点(poj3352)(6)最小割模型、网络流规约(poj3308, )三.数据结构.(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)(2)静态二叉检索树. (poj2482,poj2352)(3)树状树组(poj1195,poj3321)(4)RMQ. (poj3264,poj3368)(5)并查集的高级应用. (poj1703,2492)(6)KMP算法. (poj1961,poj2406)四.搜索(1)最优化剪枝和可行性剪枝(2)搜索的技巧和优化 (poj3411,poj1724)(3)记忆化搜索(poj3373,poj1691)五.动态规划(1)较为复杂的动态规划(如动态规划解特别的施行商问题等)(poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)(2)记录状态的动态规划. (POJ3254,poj2411,poj1185)(3)树型动态规划(poj2057,poj1947,poj2486,poj3140)六.数学(1)组合数学:1.容斥原理.2.抽屉原理.3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).4.递推关系和母函数.(2)数学.1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)2.概率问题. (poj3071,poj3440)3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)(3)计算方法.1.0/1分数规划. (poj2976)2.三分法求解单峰(单谷)的极值.3.矩阵法(poj3150,poj3422,poj3070)4.迭代逼近(poj3301)(4)随机化算法(poj3318,poj2454)(5)杂题.(poj1870,poj3296,poj3286,poj1095)七.计算几何学.(1)坐标离散化.(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一起使用).(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)(3)多边形的内核(半平面交)(poj3130,poj3335)(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)高级:一.基本算法要求:(1)代码快速写成,精简但不失风格(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)(2)保证正确性和高效性. poj3434二.图算法:(1)度限制最小生成树和第K最短路. (poj1639)(2)最短路,最小生成树,二分图,最大流问题的相关理论(主要是模型建立和求解)(poj3155,poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446(3)最优比率生成树. (poj2728)(4)最小树形图(poj3164)(5)次小生成树.(6)无向图、有向图的最小环三.数据结构.(1)trie图的建立和应用. (poj2778)(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法(RMQ+dfs)).(poj1330)(3)双端队列和它的应用(维护一个单调的队列,常常在动态规划中起到优化状态转移的目的). (poj2823)(4)左偏树(可合并堆).(5)后缀树(非常有用的数据结构,也是赛区考题的热点).(poj3415,poj3294)四.搜索(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储状态、双向广搜、A*算法.(poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)(3)深搜的优化:尽量用位运算、一定要加剪枝、函数参数尽可能少、层数不易过大、可以考虑双向搜索或者是轮换搜索、IDA*算法.(poj3131,poj2870,poj2286)五.动态规划(1)需要用数据结构优化的动态规划.(poj2754,poj3378,poj3017)(2)四边形不等式理论.(3)较难的状态DP(poj3133)六.数学(1)组合数学.1.MoBius反演(poj2888,poj2154)2.偏序关系理论.(2)博奕论.1.极大极小过程(poj3317,poj1085)2.Nim问题.七.计算几何学.(1)半平面求交(poj3384,poj2540)(2)可视图的建立(poj2966)(3)点集最小圆覆盖.(4)对踵点(poj2079)八.综合题.(poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj214 8,poj1263)--------------------------------------------------------------------以及补充Dp状态设计与方程总结1.不完全状态记录<1>青蛙过河问题<2>利用区间dp2.背包类问题<1> 0-1背包,经典问题<2>无限背包,经典问题<3>判定性背包问题<4>带附属关系的背包问题<5> + -1背包问题<6>双背包求最优值<7>构造三角形问题<8>带上下界限制的背包问题(012背包)3.线性的动态规划问题<1>积木游戏问题<2>决斗(判定性问题)<3>圆的最大多边形问题<4>统计单词个数问题<5>棋盘分割<6>日程安排问题<7>最小逼近问题(求出两数之比最接近某数/两数之和等于某数等等)<8>方块消除游戏(某区间可以连续消去求最大效益)<9>资源分配问题<10>数字三角形问题<11>漂亮的打印<12>邮局问题与构造答案<13>最高积木问题<14>两段连续和最大<15>2次幂和问题<16>N个数的最大M段子段和<17>交叉最大数问题4.判定性问题的dp(如判定整除、判定可达性等)<1>模K问题的dp<2>特殊的模K问题,求最大(最小)模K的数<3>变换数问题5.单调性优化的动态规划<1>1-SUM问题<2>2-SUM问题<3>序列划分问题(单调队列优化)6.剖分问题(多边形剖分/石子合并/圆的剖分/乘积最大)<1>凸多边形的三角剖分问题<2>乘积最大问题<3>多边形游戏(多边形边上是操作符,顶点有权值)<4>石子合并(N^3/N^2/NLogN各种优化)7.贪心的动态规划<1>最优装载问题<2>部分背包问题<3>乘船问题<4>贪心策略<5>双机调度问题Johnson算法8.状态dp<1>牛仔射击问题(博弈类)<2>哈密顿路径的状态dp<3>两支点天平平衡问题<4>一个有向图的最接近二部图9.树型dp<1>完美服务器问题(每个节点有3种状态)<2>小胖守皇宫问题<3>网络收费问题<4>树中漫游问题<5>树上的博弈<6>树的最大独立集问题<7>树的最大平衡值问题<8>构造树的最小环枚举法,常常称之为穷举法,是指从可能的集合中一一枚举各个元素,用题目给定的约束条件判定哪些是无用的,哪些是有用的。

acm编程例题 参考答案

acm编程例题 参考答案

acm编程例题参考答案ACM编程例题参考答案ACM(Advanced Computer Mathematics)是一种面向计算机科学与技术的竞赛形式,旨在提高参与者的编程技能和解决问题的能力。

ACM编程例题是指在ACM竞赛中出现的一系列编程题目,这些题目涵盖了各种算法和数据结构的应用。

本文将给出一些ACM编程例题的参考答案,希望能够帮助读者更好地理解和掌握这些题目的解法。

一、题目一:最大公约数题目描述:给定两个正整数a和b,求它们的最大公约数。

解题思路:最大公约数可以通过欧几里得算法来求解。

该算法的基本思想是,两个正整数的最大公约数等于其中较小的数和两数之差的最大公约数。

具体的实现可以使用递归或循环的方式。

代码示例:```c++int gcd(int a, int b) {if (b == 0) {return a;}return gcd(b, a % b);}```二、题目二:素数判断题目描述:给定一个正整数n,判断它是否为素数。

解题思路:素数是只能被1和自身整除的正整数。

判断一个数是否为素数可以使用试除法,即从2开始,依次判断n是否能被2到sqrt(n)之间的数整除。

如果存在能整除n的数,则n不是素数;否则,n是素数。

代码示例:```c++bool isPrime(int n) {if (n <= 1) {return false;}for (int i = 2; i * i <= n; i++) {if (n % i == 0) {return false;}}return true;}```三、题目三:字符串反转题目描述:给定一个字符串s,将其反转后输出。

解题思路:字符串反转可以通过将字符串的首尾字符依次交换来实现。

可以使用双指针的方式,一个指针指向字符串的首字符,另一个指针指向字符串的尾字符,然后交换两个指针所指向的字符,并向中间移动,直到两个指针相遇。

代码示例:```c++void reverseString(string& s) {int left = 0;int right = s.length() - 1;while (left < right) {swap(s[left], s[right]);left++;right--;}}```四、题目四:二分查找题目描述:给定一个有序数组和一个目标值,使用二分查找算法在数组中找到目标值的索引,如果目标值不存在,则返回-1。

ACM必做50题的解题-高精度

ACM必做50题的解题-高精度

POJ 1001 Exponentiation高精度数的计算,以前在网上看到过一个计算大数阶乘比如10000000!的算法,总体思想就是将结果用数组保存起来,然后将结果的每一位与乘数相乘,当然还有进位...有了这个算法的思想,这个题思路就可以是:先将输入的小数转换成一个整数,当然这个整数肯定能够用int类型的变量保存,比如1.2345, 通过函数 removeDot()将它转化成12345,然后利用大数阶乘的思想计算12345*12345.....*12345, 最后的就是输出了,这个要考虑的情况比较多,因为这个也WA了5次才AC(笨的要死), 情况虽多,但不难.这道题是高精度计算的,不算很难,但是很繁琐,尤其是对输入输出的要求。

被这道题搞了好久,耐心来,一点一点调试,总会成功的。

#include<iostream>#include<string>#include<math.h>using namespace std;char ans[10];char res[2][205];__int64 ps;//有几位小数点int len;//长度,R的有效长度//计算c = b * avoid Multiply(char * b,int bt,char * a,int at,char * c){int i,j;int up=0;for(i=0;i<at;++i){up=0;for(j=0;j<bt;j++){int t;if(c[i+j]==0)c[i+j]='0';t=(a[i]-48)*(b[j]-48)+c[i+j]-48+up;if(t>=10){up=t/10;t=t%10;c[i+j]=t+48;if(j==(bt-1) )c[i+j+1]=(up+48);}else{c[i+j]=t+48;up=0;}}}}int main(){string str;int n;int i,j;int s,t;int pos;while(cin>>str>>n){i=5;pos=str.find('.',0);if(pos<0)//没有小数点{ps=0;//zs=zs*n;//后面为0的总数}else//有小数点{ps=(5-pos);ps=ps*n;//小数位总数}memset(ans,0,sizeof(ans));memset(res[0],0,sizeof(res[0])); memset(res[1],0,sizeof(res[1])); t=5;s=0;while(str[s]=='0' || str[s]=='.') s++;j=0;for(i=t;i>=s;--i){if(str[i]=='.')continue;ans[j]=str[i];j++;}len=j;strcpy(res[0],ans);strcpy(res[1],ans);for(i=2;i<=n;++i){memset(res[(i+1)%2],0,sizeof(res[0]));Multiply(res[i%2],strlen(res[i%2]),ans,len,res[(i+1)%2]); }int L=strlen(res[(n+1)%2]);int d=(n+1)%2;if(ps>0){j=0;while(res[d][j]=='0')j++;if(ps>=L){printf(".");for(i=ps-1;i>=j ;--i){if(i>=L)printf("0");elseprintf("%c",res[(n+1)%2][i]);}}else{if(j>=ps){for(i=L-1;i>=ps;--i)printf("%c",res[(n+1)%2][i]);}else{for(i=L-1;i>=j ;--i){if(i==ps){printf("%c.",res[(n+1)%2][i]);}elseprintf("%c",res[(n+1)%2][i]);}}}}else{for(i=L-1;i>=0;--i)printf("%c",res[(n+1)%2][i]);}printf("\n");}return 0;}POJ 1047 Round and Round We Go题意:输入一个数,要求判该数是否为循环数.依次将该数分别于2到len(输入的数的位数)相乘,在乘的过程中,判断数发生了变化没有,如果发生了变化,则直接输出该数不是循环数,没有必要再继续乘下去,而如果是循环数,则一直需要乘下去.#include<iostream>#include<string>#include<cstdlib>#include<algorithm>using namespace std;int num[70];int ans[70];char ss[70];bool match[70];int main(){int i,j,k,len;bool flag;while(scanf("%s",ss)!=EOF){len=strlen(ss);for(i=len-1,j=0;i>=0;i--,j++)num[j]=ss[i]-'0';for(i=2;i<=len;i++){memset(ans,0,sizeof(ans));for(j=0;j<len;j++) //依次将该数与2到len之间的数相乘ans[j]=num[j]*i;for(j=0;j<len;j++) //循环处理进位if(ans[j]>=10){ans[j+1]+=ans[j]/10;ans[j]%=10;}memset(match,0,sizeof(match)); //match数组用来标记数的匹配情况flag=true;for(j=0;j<len;j++){k=0;while(k<len){if(ans[k]==num[j]&&!match[k]) //两数字相等且没有进行标记{match[k]=true;break;}k++;}if(k==len) //此时说明相乘后的结果发生了改变{flag=false;break;}}if(!flag){printf("%s is not cyclic\n",ss);break;}}if(flag)printf("%s is cyclic\n",ss);}system("pause");return 0;}POJ 1131 Octal Fractions给定一个八进制的小数题目要求你把它转换为十进制小数,转换后小数的位数是转换前八进制小数位数的3倍且不输出末尾无意义的零(即后置零). 我采用的方法是乘10然后对8取整(现在假设将p进制的小数转换为n进制,同样采用乘n取整:),每转换一位,都必须从最低位s[len-1]开始至小数的最高位(即小数点后的一位),每次计算积 g=a[j]*n+k(其中k为下一位积的进位),本位进位数 k=g/p,积在本位存入 s[j]=g%p;最后的整数k作为转换的一位存放于转换结果字符串中。

ACM必做50题的解题-计算几何

ACM必做50题的解题-计算几何

ACM必做50题的解题-计算几何.txt生活,是用来经营的,而不是用来计较的。

感情,是用来维系的,而不是用来考验的。

爱人,是用来疼爱的,而不是用来伤害的。

金钱,是用来享受的,而不是用来衡量的。

谎言,是用来击破的,而不是用来装饰的。

信任,是用来沉淀的,而不是用来挑战的。

POJ 1113 WALL计算几何,求凸包这题的结果等于这个多边形构成的凸包的周长加上以所给半径为半径的圆的周长步骤如下:1)算法首先寻找最最靠下方的点,如果遇到y坐标相同,则寻找x坐标最小的点firstP2)然后根据所有点相对于firstP的偏角的大小进行排序,遇到偏角相等的,只取距离firstP最远的点(排序利用自己手写的快排)3)然后利用Graham算法求凸包4)最后直接求职#include <iostream>#include <cmath>#define PI 3.1415926#define MAX_N 1000using namespace std;//存储原始输入的坐标值,rad是输入的半径double cord[MAX_N + 2][2], rad;int seq[MAX_N + 2];int stack[MAX_N + 2];int n, top;int firstP;int realN;void swap(int pos1, int pos2){int temp = seq[pos1];seq[pos1] = seq[pos2];seq[pos2] = temp;}int dir(int nodes, int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double sx = cord[nodes][0], sy = cord[nodes][1];return (x2 - sx) * (y1 - sy) - (x1 - sx) * (y2 - sy);}double getDist(int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double res = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));return res;}int compare(int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double sx = cord[firstP][0], sy = cord[firstP][1];double type = dir(firstP, node1, node2);if(type == 0){double dist1 = (x1 - sx) * (x1 - sx) + (y1 - sy) * (y1 - sy);double dist2 = (x2 - sx) * (x2 - sx) + (y2 - sy) * (y2 - sy);if(dist1 > dist2)return -2;else if(dist1 == dist2)return 0;elsereturn 2;}else if(type > 0)return 1;elsereturn -1;}void fastSort(int start, int end){if(start < end){int curPos = start;int posS = start, posE = end + 1;while(true){while(compare(seq[++posS], seq[curPos]) < 0 && posS < end); while(compare(seq[--posE], seq[curPos]) > 0 && posE > start); if(posS < posE)swap(posS, posE);elsebreak;}swap(curPos, posE);fastSort(start, posE - 1);fastSort(posE + 1, end);}}void sortSeq(){int i, s = 0;for(i = 1; i <= n; i++){//最低最左点不参加排序if(i == firstP)continue;seq[++s] = i;}realN = n - 1;fastSort(1, realN);//清理夹角相同但是距离不同的点,只取举例firstP最远的点i = 1;while(i < realN){s = i + 1;//equal angle but smaller distancewhile(s <= realN && compare(seq[i], seq[s]) == -2) {seq[s] = -1; //置为无效s++;}i = s;}}//寻找凸包void findQ(){int nodes, node1, node2, type;top = 0;stack[top++] = firstP;int s = 1;int c = 0;while(c < 2){if(seq[s] != -1){c++;stack[top++] = seq[s];}s++;}for(; s <= realN; s++){if(seq[s] == -1)continue;while(true){nodes = stack[top - 2];node1 = stack[top - 1];node2 = seq[s];type = dir(nodes, node1, node2);if(type >= 0)top--;elsebreak;}stack[top++] = seq[s];}}double getRes(){double totalDist = 0;int lastNode = firstP;int curNode;while(top > 0){curNode = stack[--top];totalDist += getDist(lastNode, curNode);lastNode = curNode;}//totalDist += getDist(lastNode, firstP);totalDist += 2 * PI * rad;return totalDist;}int main(){int i;cin>>n>>rad;int minX = INT_MAX, minY = INT_MAX;for(i = 1; i <= n; i++){cin>>cord[i][0]>>cord[i][1];if((cord[i][1] < minY) || (cord[i][1] == minY && cord[i][0] < minX)){firstP = i;minX = cord[i][0];minY = cord[i][1];}}sortSeq();findQ();double res = getRes();printf("%.0f\n", res);return 0;}POJ1292 Will Indiana Jones Get There?题目大意:英雄Jones现在在位置1,有人在位置2呼救,所以他要过去救他,但是有个条件,他必须在墙上走,其实就是说他只能在图示的线段上走,但是线段间有空隙,所以要用一个长板搭在线段间才能从一个线段到另外一个线段,问怎么找到一个路径使得要使用的长板最小。

蓝桥杯ACM决赛经典试题及其详解

蓝桥杯ACM决赛经典试题及其详解

/*入门训练A+B问题问题描述输入A、B,输出A+B。

说明:在“问题描述”这部分,会给出试题的意思,以及所要求的目标。

输入格式输入的第一行包括两个整数,由空格分隔,分别表示A、B。

说明:“输入格式”是描述在测试你的程序时,所给的输入一定满足的格式。

做题时你应该假设所给的输入是一定满足输入格式的要求的,所以你不需要对输入的格式进行检查。

多余的格式检查可能会适得其反,使用你的程序错误。

在测试的时候,系统会自动将输入数据输入到你的程序中,你不能给任何提示。

比如,你在输入的时候提示“请输入A、B”之类的话是不需要的,这些多余的输出会使得你的程序被判定为错误。

输出格式输出一行,包括一个整数,表示A+B的值。

说明:“输出格式”是要求你的程序在输出结果的时候必须满足的格式。

在输出时,你的程序必须满足这个格式的要求,不能少任何内容,也不能多任何内容。

如果你的内容和输出格式要求的不一样,你的程序会被判断为错误,包括你输出了提示信息、中间调试信息、计时或者统计的信息等。

样例输入12 45说明:“样例输入”给出了一组满足“输入格式”要求的输入的例子。

这里给出的输入只是可能用来测试你的程序的一个输入,在测试的时候,还会有更多的输入用来测试你的程序。

样例输出57说明:“样例输出”给出了一组满足“输出格式”要求的输出的例子。

样例输出中的结果是和样例输入中的是对应的,因此,你可以使用样例的输入输出简单的检查你的程序。

要特别指出的是,能够通过样例输入输出的程序并不一定是正确的程序,在测试的时候,会用很多组数据进行测试,而不局限于样例数据。

有可能一个程序通过了样例数据,但测试的时候仍只能得0分,可能因为这个程序只在一些类似样例的特例中正确,而不具有通用性,再测试更多数据时会出现错误。

比如,对于本题,如果你写一个程序不管输入是什么都输入57,则样例数据是对的,但是测试其他数据,哪怕输入是1和2,这个程序也输出57,则对于其他数据这个程序都不正确。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

求最值
时间限制(普通/Java) : 1000 MS/3000 MS运行内存限制: 65536 KByte
总提交: 9915 测试通过: 2804
比赛描述
给定N个整数(1<=N<=100),求出这N个数中的最大值,最小值。

输入
多组数据,第一行为一个整数N,第二行为N个不超过100的正整数,用空格隔开。

输出
对每组数据输出一行,包含两个整数,用一个空格隔开,分别表示N个数中的最大值和最小值
样例输入
5
4 6 7 3 1
4
4 3
5 1
样例输出
7 1
5 1
#include <stdio.h>
int main()
{
int str[101];
int i,n;
for(;scanf("%d",&n)==1;)
{
int max=-1;
int min=101;
if(0<=n&&n<=100)
{
for(i=0;i<n;i++)
{
scanf("%d",&str[i]);
max=max>str[i]?max:str[i];
min=min<str[i]?min:str[i];
}
}
printf("%d %d\n",max,min);
}
return 0;
}
斐波那契数列
时间限制(普通/Java) : 1000 MS/10000 MS运行内存限制: 65536 KByte
总提交: 6917 测试通过: 2394
比赛描述
在数学上,斐波那契数列(Fibonacci Sequence),是以递归的方法来定义:
F
= 0
= 1
F
1
F n = F n - 1 + F n - 2
用文字来说,就是斐波那契数列由0和1开始,之后的斐波那契数就由之前的两数相加。

首几个斐波那契数是:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946,………………
特别指出:0不是第一项,而是第零项。

在西方,最先研究这个数列的人是比萨的列奥纳多(又名斐波那契),他描述兔子生长的数目时用上了这数列。

⏹ 第一个月有一对刚诞生的兔子
⏹ 第两个月之后它们可以生育
⏹ 每月每对可生育的兔子会诞生下一对新兔子
⏹ 兔子永不死去
假设在n 月有新生及可生育的兔子总共a 对,n+1月就总共有b 对。

在n+2月必定总共有a+b 对:因为在n+2月的时候,所有在n 月就已存在的a 对兔子皆已可以生育并诞下a 对后代;同时在前一月(n+1月)之b 对兔子中,在当月属于新诞生的兔子尚不能生育。

现请以较短的时间,求出斐波那契数列第n 项数值,0≤n ≤40。

输入
斐波那契数列项数n ,0≤n ≤40。

输出
斐波那契数列第n项数值
样例输入
4
样例输出
3
#include <stdio.h>
const int n=40;
int main()
{
int i,m;int str[n];
str[0]=0;str[1]=1;
scanf("%d",&m);
switch(m)
{
case 0:printf("%d",str[0]);break;
case 1:printf("%d",str[1]);break;
default:
for(i=2;i<=m;i++)
{
str[i]=str[i-1]+str[i-2];
}
printf("%d\n",str[m]);
}
return 0;
}
完美立方
时间限制(普通/Java) : 1000 MS/3000 MS运行内存限制: 65536 KByte
总提交: 5492 测试通过: 1440
比赛描述
a3 = b3 + c3 + d3为完美立方等式。

例如123 = 63 + 83 + 103。

编写一个程序,对任给的正整数N (N≤100),寻找所有的四元组(a, b, c, d),使得a3 = b3 + c3 + d3,其中1<a, b, c, d ≤N。

输入
正整数N (N≤100)
输出
每行输出一个完美立方,按照a的值,从小到大依次输出。

当两个完美立方等式中a的值相同,则依次按照b、c、d进行非降升序排列输出,即b值小的先输出、然后c值小的先输出、然后d值小的先输出。

样例输入
24
样例输出
Cube = 6, Triple = (3,4,5)
Cube = 12, Triple = (6,8,10)
Cube = 18, Triple = (2,12,16)
Cube = 18, Triple = (9,12,15)
Cube = 19, Triple = (3,10,18)
Cube = 20, Triple = (7,14,17)
Cube = 24, Triple = (12,16,20)
#include <stdio.h>
#include <math.h>
void Cube(int n);
int main()
{
int N,m;
scanf("%d",&N);
for(m=1;m<=N;m++)
{
Cube(m);
}
return 0;
}
void Cube(int n)
{
int i,j,k;
double a,a1,b,c;
a=pow(n,3);
for(i=2;i<n;i++)
{
b=pow(i,3);
for(j=i;j<n;j++)
{
c=pow(j,3);
for(k=j;k<n;k++)
{
a1=b+c+pow(k,3);
if(a1==a)
printf("Cube = %d, Triple = (%d,%d,%d)\n",n,i,j,k);
}
}
}
}。

相关文档
最新文档