求余就是算除法值是他的余数doc.docx
《求余就是算除法值是他的余数doc.docx》由会员分享，可在线阅读，更多相关《求余就是算除法值是他的余数doc.docx（32页珍藏版）》请在冰点文库上搜索。
求余就是算除法值是他的余数doc
“％”求余，就是算除法，值是他的余数
“/”这个是除法，但是有一点注意，两边操作数全为整数时,值是取整的。
1、
如果一个位数等于其各位数字•的立方和,则称这个数为水仙花数。
编写一个程序，找出全部的水仙花数。
*/
#include〈stdi（）・h>#include〈c（）ni（）・h>voidmain（）
inti,j,k,n;
printfC=
printfC水仙花数是:
”）;for（n=100;ni二n/100;
j=n/10-i*10;
k二n%10;
if（n==i*i*i+j*j*j+k*k*k）printf（"%d\n",n）;
}
printf（"\n"）;
getch（）;
}
2、
/*判断闰年*/
ftinclude#includo〈c（）ni（）・h>
voidmain（）
{
intyear,leap;
printf（"二二二二二二二二二二二二二二二二二二二二二二二二二二二二二\rT）；
printf（〃请输入一个年份，请注意输入数值为四位数字：
”）;scanf（"%d",&year）;
if（（year%4==0&&year%l00!
=0）||（year%400==0））
leap=l;
else
leap-0;
if（leap）
printf（^d是闰年<»\n",year）;
else
printfC%d不是闰年。
\rT,year）;
getch（）;
3、
上
/gwS"S"S"S"S"S"*pSi*1^S"S"S”S"S"gw*1^S"S"S"S"
叫、％、叫、叫、叫、叫、叫、叫、叫、叫、叫、叫、叫、彳、叫、叫、叫、叫、叫、彳、叫、叫、叫、彳、叫、彳、
*问题：
在你面前有一条长长的阶梯。
如果你毎步跨阶，
*那么最后剩下阶：
如果你毎步跨阶，那么最后
*剩阶；如果你每步跨阶，那么垠后剩阶；如果
*你毎步跨阶，那么垠后剩阶；只有当你毎步跨
*7阶时，最后才正好走完，一阶也不剩。
*请问这条阶梯至少有多少阶？
*分析：
所求的阶梯数应比2、、、的公倍数
*（即30的倍数）小1,并且是7的倍数。
*因此只需从29中找
*7的倍数就可以了。
可以得到答案为119阶
*T*»T*»T**T*/
#include
#includo〈c（）ni（>・h>
voidmdin（）
{
intsteps二29,i二1;
while（steps%7）
{
steps二（30*++i）-1;
}
printfC阶梯共右•：
％d阶"，steps）;
getch（）;
}
4、
/*
*如果一个数恰好等于它的因子z和，
*那么这个数就被称为完金数。
*例如的因子为，，，
*而二1+2+3,因此是一个完全数。
*求出以内的完全数。
*/
#includeh>
#includc〈c（）ni（>・h>
voidmain（）
{
intm,s,i;
/*循环控制选取'1000中的各数进行判断*/
for（m=2;m<1000;m++）
s=0;
/*计算m的因子，并将各因子Z和mF,贝叽是完全数输出*/for（i=l;iif（（m%i=O））
s二s+i;
if（s==m）
{
printfC%d是完全数,它的因子分别是:
"』）；
/*输出完全数的因子*/
for（i-l;iif（m%i—0）
printf（"%d,“，i）;
printf（"\n"）;
}
）
getch（）;
}
5、
/*
正整数n若是它平方数的尾部，则称n为同构数。
编写一个程序，找出以内的同构数。
*/
#include
#include〈c（）ni（）.h>
voidmain（）
{
longintx,y,i=10;
intflag=0;
for（x=l;x<1000;x++）
{
y=x*x;
while（y/i!
=0）//利用循环取余的方法进行判断
{
//先让y对取余，判断是否是同构数if（y%i==x）/再对取余判断,直到yi为
{
flag=l;
break;
}
i-i*10;
1
if（flag=l）
printf（/z\n%dJl%d的同构数!
",x,y）；
flag=0;
i=10;
}
getch（）;
}
6、
7、/*递归反向输出字符串*/
^include
ltinclu（Je
voidrev_print（char*x）
{
if（*x）
rev_print（x+1）;
else
return;
putchdr（*x）;
}
voidmain（）
{
charline[80];
printf（"请输入一个字符串:
\n"）;
gets（line）;
revprint（line）;
getch（）;
}
8、/*求址大公约数、最小公倍数*/
#include〈stdi（）・h>
#include〈c（）ni（）・h>
voidmdin（）
{
intp,r,n,m,temp:
printf（*=============================\n"）;
printf（，?
请输入两个正整数：
"）；
scanf（〃％d,%d,"，&n,&m）;
if（n{
ternp二ri;
n=m;
m=temp;//把大数放在n中,小数放在m中
}
P=n*m;先将n和m的乘积保心在p屮，以便求最小公倍数时用
while（mJ^O）
{
r=n%m;
n二m;
in=r;
printf;
printfC他们的最大公约数为：
％d\n〃,n）;
printf（"他们的垠小公倍数数为：
％d\n〃,p/n）;//p为原來两个数的乘积getchO;
课本上的算法
1、/*背包问题的贪心算法*/
#include
#include〈c（）ni（）・h>
floatw[10],pp[10],weight;//每件物品匝量/效益/背包容量
intcount;个数
floatp；'总效益
typedefstruct{
intk;
//物品序号
boolflag;
//
floatpor;
//
物体的比例
floatv;
//
物体的价值用最比
}Object;
Objectx[10];
voidGREEI）Y_KNAPSACK（）
{
floatcu;〃背包的剩余容最
cu二weight;
inti;
intseq二1;
while（l）
{
floatmax=0.0;
for（irrtm二1;m{
if（x[m]・flag&&x[in]・v>iirix）{niax=x[m]・v;seq=m;}
}
x[seq]・flag=false;
if（w[seq]>cu）
break;
else
x[seq].por=l.0;
cu=cu-ww[seq];
）
x[seq].por=cu/w[seq];
printf（〃*********求解如下：
*********、n〃）；
for（ints=l;s{
printf（，z[%d]%f\n",x[s].k,x[s].por）;
p+=pp[s]*x[s].por;
}
printfC总效益:
%f\rT,p）;
}
voidmainO
{
printf（^请输入背包容最：
"）；
scanf^weight）;
printf（"请输入物品个数：
“）；
scanf（"%d",&c（）unt）;
pdntf（"请输入物品匝最及效益值\n〃）；
printfC物品序号重量效益\『）;
for（intt=l:
t{
printfC【%d】",t）;
scanf（"%f%f",&ww[t],&pp[t]）;
x[t].v二pp[t]/ww[t];
x[t].k=t;
x[11.flag二true;
x[t.1.por=0.0;
}
GRFEI）Y_KNAPSACK（）;
getch（）;
}
2、/*二分检索：
折半查找-一-
睿思想：
先对数纽进行排序，然后利用-•.分检索进行査找*/
#include
#include
//快速査找方法
intSearch（intd[],intlow,inthigh,intx）
intmid;
mid二（lo\v+high）/2;if（low>high）
returnT;
}
else
{
if（x==a[mid]）
returnmid;
elseif（xhigh=mid-l;
else
low=mid+l;
Search（a,low,high,x）;
）
}
〃排序方法
voidSort（intd[],intlen）
{
for（intiN;i{
for（intj二0;j〈len-i;j卄）
{
if（a[j]>a[j+l]）
{
inttemp=a[j];
a[j]=a[j+l];
a[j+l]=temp;
}
}
）
}
voidmain（）
{
intSearch（inta[],intlow,inthigh,intx）;'声明voidSort（inta|I,intlen）;
//a[6]数组，记录输入的数据
//x代表输入查找的数
//j记录输入查找数的位置
inta[5],1（加0,high二5,j,x;
printf（，z请输入数组元索的值：
\n〃）；
for（inti-0;i<6;i++）
}
Sort（a,6）;/排序方法
printf（/，递增排序后数组元索的值：
\n〃）；
〃输出排序后的数值
for（intt二0;t〈6;t++）
{
printf（"d[%d]=%d\n",t,a[t]）;
}
printf（，z请输入所要查找元索的值：
“）；
scanf（"%d：
&x）;
//査找方法
j二Search（d,low,high,x）;
if（j==-l）
printf（，z所要査找元索不血El数纽！
\n"）;
else
Mintf（〃所要查找元素在原数组第M个位置\n",j+1）;getch（）;
}
3、/*快速分类算法*/
#include
#include
intA[11];
//划分数组
voidPARTITION（intm,int*p）
{
intv,i;
v=A|m];i二m;
while（l）
{
do
{
i+二1;
}
while（A[i|do
{
*p-=l;
}
while（A[*p]>v）;
if（i<*p）
inttemp^AtiI;
A[i]=A[*p];
A[*p]=temp;
elsebreak;
）
A[m]=A[*p];A[*p]=v;
return;
}
〃快速排序
voidQUICKSORT（intp,intq）
{
intj;
if（p{
j二q+1；
PARTITION（p,&j）;
QUICKSORT®,j-l）;
QUICKSORT（j+l,q）;
）
return;
}
//选择第k小元素
voidSELECT（intk）
{
intm=l,j,r;
r-9;
while
（1）
{
j=r;
PARTITION（m,&j）;
if（k==j）
{
printf（"第％d小兀素楚％d:
\n",j,A[j]）;break;
}
elseif（kelsem=j+l;
}
}
voidmain（）
{
inti;
printf（3fi输入数组元索的值：
\n〃）；
A[10]=255;
for（i=l;i<=9;i++）
printf（，，A[%d]=，，>i）;
scarif（"%d",&A[i]）;
）
QUICKSORT（1,9）;
printf（"快速排序后数组元素的值:
\n"）;
for（i=l;i<=9;i++）
{
printf（"A[%d]=%d\n",i,A[i]）;
）
intk;
printf（3fi输入数组中所要査找的第儿小元索的值：
〃）；scanf（"%d",&k）;
SELECT（k）;
getch（）;
}
Kf***************多段图的向前处理舁浓***************
procedureFGRAPH（E,k,n,P）
//输入是按段的顺序给结点编号的，有n个结点的k段图。
E是边集,c（i,j）是边的成本oP（l:
k）带出最小成本路径//realCOST（n）:
integerD（n-l）,P（k）,r,j,k,n
COST（n）<-
forj<—n~lto1by-1do//计算COST（j）//
设r是具有性质：
〈j,r>GE.H.使c（j,r）KOST（r）取最小值的结点
COST（j）—c（j,r）+COST（r）
D（j）-r〃记录决策值//
repeat
P（l）<-;P（k）<-n
torj-tok-1do〃找路径上的第j个结点//
P（j）-D（P（j-l））〃回溯求出该路径//
repeat
endFGRAPH*/
/***************多段图的向后处理算法***************
procedureBGRAPH（E,k,n,P）
//输入是按段的顺序给结点编号的，有n个结点的k段图。
E是边集，c（i,j）是边的成本。
P（l:
k）帶出最小成本路径//realBCOST（n）;integerBD（nT）,P（k）,r,j,k,n
BCOST
（1）<-
forj<—tondo//计算BCOST（j）//
设r是具^GE.H.使BC0ST（r）+c（r,j）取最小值性质的结点
BCOST（j）<-BCOST（r）+c（r,j）
BD（j）<-r〃记录决策值〃
repeat
P（l）<-;P（k）<-n
forj-k-lto2by-1do〃找路径上的第j个结点//
P（j）-D（P（j+l））〃冋溯求出该路径//
repeat
endBGRAPH*/
#include
^include
intE[13][13];//邻接矩阵:
存放段图，其中E[0][],E[][0]不用
#definen12//有n个结点的k段图
#definek5
voidFGRAPHO
{
intCOST[13];
intD[13],P[6];
C0ST[12]=0;
inti3;
for（i3=ll;i3>0;i3—）
{
//i•是具有性质:
eE且使E[i3][r]+C（）ST[r]取最小值的结点intr;
intmin=500;
for（inti6=i3+l;i6<13;i6++）
{
if（E[i3][i6]!
=0&&（E[i3][i6]+C0ST[i6]）{
min=E[i3][i6]+C0ST[i6];
r=i6;
}
}
C0ST[i3]=E[i3][r]+C0ST[r];
I）[i3]=r;
}
P[l]=l；P[k]=n;
for（inti4二2;i4〈二k-l;i4++）//找路径上的第j个结点//
{
P[i4]=D[P[i4-l]];//冋溯求出该路径//
}
//
p“ntf（"\n<«<〈《BEGlN〈《<<«\n\rr）;
printf（"最小成本:
%d\n\n其路径:
",COST[1]）;
for（inti5=l;i5<=k;i5++）
printf（"%d",P[i5]）;
printf（"\n\n*******OVER*******\n"）;
voidBGRAPHO
{
intBCOST[13]:
intD[13],P[6];
BCOST[1]=O;
inti3;
for（i3=2;i3<=12;i3++）
{
//r是具有性质:
eEK使C0ST[r]+E[i3][r]取最小值的结点intr;
intmin二500;
for（inti6=i3-l;i6>0;i6—）
{
if（E[i3][i6]!
=0&&（BC0ST[i6]+E[i3][i6]Xmin）
{
min-BC0ST[i6]+E[i3][i6];
r二i6;
}
}
BC0ST[i3]=BC0ST[r]+E[i3][r];
I）[i3]=r;
）
P[l]=l;P[k]=n;
for（intil=k-l;i4>=2;i4—）〃找路径上的第j个结点//
{
P[i4]=D[P[i4+l]];//回溯求出该路径//
}
printf（*\n»»»>BEGIN»»»>\n\n'）;
printf（"最小成木:
%d\n\n其路径:
”,BCOST[12]）;
for（int,i5=l;i5<=k;i5++）
{
printf（*%d",P[i5]）;
）
printf（"\n\i】*******0VER*******\f）;
}
voidmain（）
{
//赋初值
//第一段
E[l]⑵二9;
E[l][3]=7;
E[l][4]=3;
E[l][5]=2;
//第二段
E⑵⑹=4;
E[2]⑺二2;
E[2][8]=l;
E[3][6]=2;
E[3][7]=7;
E[4][8]=ll;
E[5][7]=ll;
E[5][8]二8;
//第三段
E[6][9]-6;
E[6][10]=5;
E[7]⑼二4;
E[7][10]=3;
E[8][10]=5;
E[8][ll]=6;
//第四段
E[9][12]=4;
E[10][12]=2;
E[ll][121=5;
for（intil=l;il<13;il++）
{
for（inti2二il+l;i2<13;i2++）
{
E[i2][il]=E[il][i2];
}
}〃使邻接矩阵对称
〃输出邻接炬阵
printf（"\n*********输出该图邻接炉阵*********\n"）;
intj=0;//行for（inti1=1;il<13;il++）
{
for（inti2=l;i2<13;i2卄）
{
if（j%12=0）printf（"\n"）;//每十二个数一行
if（E[il][i2]/10=0）{printfC%d",E[il][i2]）;j++;}//—位数elseif（E[il][i2]/10==l）{printf（*%d",E[il][i2]）;j++;}.//两位数else{printf（v%d",E[il][i2]）;j++;}//对本程序无用,可不要
}
1
printf（，z\n\n***********【算法实现】材材材材材*\n\n"）;
FGRAP1IO;printf（*\n«««««««««»»»»»»»»>\n*）;
printfC\rT）;
BGRAPIlO;
getch（）;
}
5、/*图的宽度优先遍丿力*/
#inc1ude
usingnamespacestd;
#include
#includo
#defineMax20
typedefstructNode
{
intnum;
structNode*next;
}Node;
NodeG[Max];
intvisited[Max];
intQ[Max];
intfront二0,rear二0;
boolemptyQueue（intQ丨]）{
if（rear=front）
returntrue;
else
returnfalse;
}
voidEnQueue（intQ[],inte）
{
Q[rear]=e;rear=rear+l;
}
voidDeQueue（intQ[],int*e）
{
*e=Q[front];front=front+l;
}
voidCreatagraph（intn,NodeG[]）
inti,e,j;
Node*p,*q;
for（i=0;iG[i].num=i;
G[i].next=NULL;
）
for（i^O;i{
//printfC"请输入第i个顶点相邻节点信息：
%d”）;
//scdnf（"陽d",&e）;
cout"«endl;
cin»e;
j二0;
while（e!
=-l&&j{
p二（Node*）malloc（sizeof（Node））;
p->next二NULL;
p->num=e;
j++；
if（G[i].next==NULL）
{
GIi].next二p;
}else
q->next=p;
q=p;
//printf（"请继续输入：
"）;
//scanf（"%d",&e）;
cout<<"请继续输入：
"<cin»e;
}
}
}
intFirst（NodeG[],intv）
{
if（G[vI.next!
二NULL）
{
returnG|v].next->num;
}
return-1;
}
intNext（NodeG[],intv）
Node*p;p=G[v]
升级会员 