算法设计

汉诺塔算法：
main( )
{ int n;
input(n);
Hanoi(n,”A”,”B”,”C”)；}
Hanoi(int n,char a,char b,char c)
{ if(n>0) { hanoi(n-1,a,c,b);
输出（”move dish”,n,”from pile”,a”to”b）; Hanoi（n-1,c,b,a）;}}
数字编号“翻译”成英文编号：35706“there-five-seven-zero-six”
main（）
{ int i，n; char num[10];
char eng[10][6]={“zero”,”one”,”two’’，“three”，“four“，
“five”，
“six”，“seven”，“eight”，“nine”}; print(“Input a num:”); input(num);
n=strlen(num);
if(n=0) print(“input err”);
else {
print(num,“English_exp:”,eng[num[0]-48]); for(i=0;i<n;i++) print(“-”,eng[num[i]-48]);}} 编写算法对输入的一个整数，判断它能否被4，7，9整除，并输出以下信息之一，能同时被4，7，9整除；能被其中两个数（要指出哪两个数）整除；能被其中一个数整除（要指出哪一个数）；不能被4，7，9任一个整除。

main()
{long n; int k;
print("Please input a number:"); input(n);
k=(n mod 4=0)+(n mod 7=0)*2+(n mod 9=0)*4; switch(k){
case 7:print("All");break;
case 6:print("7 and 9");break;
case 5:print("4 and 9");break;
case 4:print("9");break;
case 3:print("4 and 7");break;
case 2:print("7");break;
case 1:print("4");break;
case 0:print("none");break;}}
为保证取款张数最少，要统计出所需各种币值(100，50，20，10，5，2，1)共七种张数
main()
{ int i,j,n,GZ,A,
B[8]={0,100,50,20,10,5,2,1},
S[8]={0,0,0,0,0,0,0,0};
input(n);
for(i=1;i<=n;i=i+1)
{input(GZ)
for(j=1;j<=7;j=j+1)
{ A=GZ/B[j];
S[j]=S[j]+A;
GZ=GZ-A*B[j];} }
for(i=1;i<=7;i=i+1)
print(B[j],"....",S[i]);}
数塔问题（填空）
{int a[50][50][3],i,j,n;
print("Please input the number:");
input(n);
for(i=1;i<=n;i=i+1)
for(j=1;j<=i;j=j+1)
{ input(a[i][j][1]);
a[i][j][2]=a[i][j][1];
a[i][j][3]=0;}
for(i=n-1;i>=1;i=i-1)
for(j=1;j<=i;j=j+1)
if(a[i+1][j][2]>a[i+1][j+1][2])
{a[i][j][2]=a[i][j][2]+a[i+1][j][2];
a[i][j][3]=0;}
else
{a[i][j][2]=a[i][j][2]+a[i+1][j+1][2];
a[i][j][3]=1;}
print("max=",a[1][1][2]);
j=1;
for(i=1;i<=n-1;i=i+1)
{print(a[i][j][1],"->");
j=j+a[i][j][3];}
print(a[n][j][1]);}
请编程求1*2*......*n得数末尾有多少0？（填空）main()
{ int i,n,sum=0;
int zero(int x);
print("请输入n(1000<n<10000):");
input(n);
for(i=1;i<=n;i++) sum=sum+zero(i);
sum+=n/10;
if((n%10)>5) sum++;
printf("所求末尾有%d个0.\n",sum); }
int zero(int x)
{if(x%1000==0) return 3;
else if(x%100==0)return 2;
else if(x%10==0)return 1;
else return 0;}
给定任意n值，输出螺旋阵（设计）
main(){
int i,j,k,n,a[100][100],b[2],x,y;
input(n);
b[0]=0;
b[1]=1;
k=n;
t=1;
x=1;
while(x<n*n) {
for(y=1;y<=2*k-1;y=y+1){
b[y/(k+1)]=b[y/(k+1)]+t;
a[b[0]][b[1]]=x;
x=x+1;}
k=k-1;
t=-t;}
for(i=1;i<=n;i++) {
printf("\n");
for(j=1;j<=n;j++)
pintf(a[i][j]); ｝｝把一个真分数表示为埃及分数之和形式，如7/8=1/2+1/3+1/24. （设计）
main()
{int a,b,c;
printf("input element");
intput(a);
printf("input denominator");
input(b);
if(a>=b)
printf("input error");
else if(a=1 or b mod a=0)
printf(a,"/",b,"=",1,"/",b/a);
else while(a<>1)
{ c=b/a+1;
a=a*c-b;
b=b*c;
printf("1/",c);
if(a>1) printf("+");
if（b mod a=0 or a=1）
{ printf("1/",b/a);
a=1;}}}
1.贪婪算法以逐步的局部最优，达到最终的全局最优；贪婪算法无固定算法框架，算法设计的关键是贪婪策略的选择，所选择的贪婪算法要具有后向性：即某状态以后的过程不会影响以前的状态。

2. 贪婪策略算法设计框架:
①贪心法的基本思路:从某一初始解出发逐步逼近给定目标,且每一步都作不可回溯的决策;
②该算法使用的问题：局部最优策略能导致全局最优解；
③该策略的算法框架：从问题的某一初始解出发，利用可行的决策，求出可行解。

④贪婪决策的选择。

3.动态规划是（多阶段最优决策）解决问题的过程，主要针对最优化问题，它是全面考虑各种不同的情况分别进行决策，最后通过多阶段决策逐步找出问题的最终解。

每次决策依赖于当前状态，又随即引起状态的转移。

4. 动态规划算法设计框架：
⑴适用动态规划策略解决问题的特征：①不能在决策中失去问题的最优解；②要满足无后向性。

（三个性质：最优化原理、无后向性、子问题重叠性质。

）
⑵动态规划基本思想：把求解的问题分成许多阶段或多个子问题，然后按顺序求解子问题。

⑶设计动态规划算法的基本步骤：划分阶段，选择状态，确定决策并写出状态转移方程。

⑷动态规划算法基本框架。

1.（霍夫曼）树，（构造最小生成树的Prim算法)和(Kruskal算法)的决策过程,都使用了贪婪算法策略.
计算机求解问题的步骤：问题分析、数学模型建立、算法设计与选择（核心）、算法表示、算法分析、算法实现、程序调试、结果整理文档编制。

2.一个简单问题的求解过程：
①问题分析：确认问题的逻辑结构和基本功能，并建立数学模型；
②算法设计：找出解决问题的处理步骤；
③对数学模型的建立，数据结构的选择及算法设计工作的评价总结。

3.数量级关系：O（1）<O（logn）<O（n）<O（n^c）
4.P类问题：存在多项式时间算法的一类问题，是所有复杂度为多项式时间的问题集合。

可以在多项式时间内验证一个解是否正确的问题称为NP问题。

NP完全类是NP类问题的复杂性最高的一个子类。