C语言中sin()函数用的什么算法？
C语言中sin()函数用的什么算法？
09-09-07 &
这个是库函数吧只有有说明就可以用了，你试一下，不用包含 math.h 直接写一个声明，double _Cdecl sin (double x);就可以用了库函数没有源文件可以看的，只有二进制可执行代码连接时，加到你的程序中。这是编译器提供的。--------------------补充一下楼主问的是 sin 这个函数，CPU是如何实现的CPU能做加减乘除还有逻辑运算不知道楼主有没有学过极数？把sin(x)按 泰勒极数展开，可以变在一个 sin(x)=f(x)f(x) 是一个关于x的加减乘除的函数，极数无限的当然，极数越多，精度越高，运算量越大计算机取有限极数，作近似计算即可sin(x)=x-x^3/3!+x^5/5!-x^7/!+....
请登录后再发表评论!您所在的位置： &
如何选择适合自己的云计算编程语言组合?
如何选择适合自己的云计算编程语言组合?
布加迪编译
说到选择要使用的编程语言组合，既有正确的方式，也有错误的方式。本文帮助云计算开发人员迈上正确的道路。
说到选择要使用的编程语言组合，既有正确的方式，也有错误的方式。本文帮助云计算开发人员迈上正确的道路。
用CSS编写的《辛普森一家》(The Simpsons)，这个项目出自开发人员Chris Pattle之手。
知识论坛Big Think拍摄了一则采访C++编程语言发明者Bjarne Stroustrup的视频：&编程人员应该知道的五门最重要的语言是什么?&他说。&要是他们只知道一门语言，就没资格自称是专业开发人员。&
所以在Stroustrup看来，说&我喜爱Perl。世界上只有一门语言，那就是Perl。&没什么用。如果入门级开发人员摸透了擅长的第一门语言，想在云计算领域大有作为，就需要学会好几门编程语言，才有一席之地。那么到底是哪几门呢?云计算开发人员应该挑选哪几门编程语言?
按人气来挑选语言?
如果一名初出茅庐的开发人员需要赚钱，不妨留意雇主要求的编程语言。IEEE Top Programming Languages这款应用程序(http://spectrum.ieee.org/static/interactive-the-top-programming-languages，需要注册)详细列出了这些语言。
大家也忍不住想选择人气最量的语言。GitHub上的前20门编程语言()概述了这方面的情况。
不过，以这种方式挑选语言会导致你的编程语言组合零敲碎打。这是个问题，一方面是由于开发人员最后并不通晓一大批广泛的语言类型(偏向通用语言)，一方面是由于这隐藏了开发的细节。
立旨想成为微软Azure开发人员的人需要能够开发整套系统。一名优秀的微软开发人员也许熟悉这一系列语言：C#、HTML5、LINQ、NHibernate和ASP.NET。什么?它们并不都是语言啊?可它们都含有语言。要是有词汇、正式语法，而且需要开发人员编写代码，那它就是一门语言。
按类别挑选语言!
如果一名开发人员确实想认真掌握一大批语言专长，就应该在这五个类别寻找他们喜欢的语言。这里包括了十个语言例子，可以帮助崭露头角的编程人员尽快上手。
数据是所有云计算的核心(想一想物联网和大数据)，这让数据语言成为一门最重要的语言。UML和SGML是用于数据建模的描述语言。HTTP含有用于处理数据的CRUD(创建、更换、更新和删除)命令。
数据语言是一款神奇的工具，可以将大数据变成商业金矿。而云中有大量的数据。数学家们喜爱MATLAB和R。Fortran不仅是最悠久的例子，它还是各门编程语言中最古老的语言之一。
这个函数是指数据函数，而不是编程功能。通用函数语言常常含有数学语言的特征。你在云计算中不会找到太多的LISP(最古老的函数语言)，但会找到大量的Clojure(最新颖的函数语言)。
这是大多数人一想到计算机语言就会想到的一门编程语言。过程语言中的逐步指示可以隐藏所有的繁重工作(就像JavaScript那样)，或者暴露低级特性(就像C那样)。GitHub上的前20门编程语言和IEEE前10门编程语言中大部分是过程语言。
特定领域语言
特定领域语言是语言领域的大杂烩式组合。&特定领域&是那些有用但又模糊的集合名词之一。你可以说，每门语言存在于某个领域DD比如说，所有数学语言都存在于数学领域。然而，这个术语通常适用于解决特定问题的小语言。
一种流行的特定领域语言集合在于云和人之间的接口：Web。前端开发人员可能使用通用编程语言(比如说PHP)和许多特定领域语言(比如CSS、HTML、SOAP和YAML)，开发实用的网站。
开发是出于爱好还是赚钱?
对开发新手来说，选择编程语言组合比开发老手来得容易。云计算的规模意味着，工作是由商业团队，而不是个人完成的。而说到支付费用，开发人员不得不使用雇主要求的语言。
另一方面，如果一名经验丰富的开发人员想学习新的技能，他们可以选择一个开源云项目，在业余时间贡献代码。这方面选择很广泛，他们可以选择自己偏爱的任何一门语言。如果这个想法很吸引你，不妨访问OpenHatch(http://openhatch.org)，寻求帮助。
原文标题：How to choose your portfolio of cloud programming languages
【编辑推荐】
【责任编辑： TEL：（010）】
关于&&&&&&的更多文章
《Android应用程序开发权威指南（第四版）》是Android应用程序开
180天的Windows Server 2012试用版下载（标准版或数据中心版）
讲师： 534人学习过讲师： 4796人学习过讲师： 2488人学习过
Windows Server 2012是微软公司改良研发中的下一代服
在36小时的应用马拉松中，微软安排了各类互动环节以鼓
2月28日下午，微软在中国正式发布Office 365企业版，
本书对第1版的某些章节作了合理的调整,增加了部分实用的程序,并在每一章的最后加了适量的练习题,以巩固前面所学的知识,更加有利
51CTO旗下网站&&&&&&&&&&&&&&&&&&
posts - 396,comments - 44,trackbacks - 0
一、什么是算法
算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。算法常常含有重复的步骤和一些比较或逻辑判断。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n 的函数f(n)，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度（Asymptotic Time Complexity）。时间复杂度用&O（数量级）&来表示，称为&阶&。常见的时间复杂度有： O（1）常数阶；O（log2n）对数阶；O（n）线性阶；O（n2）平方阶。
算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。
二、算法设计的方法
递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。设要求问题规模为N的解，当N=1时，解或为已知，或能非常方便地得到解。能采用递推法构造算法的问题有重要的递推性质，即当得到问题规模为i-1的解后，由问题的递推性质，能从已求得的规模为1，2，&，i-1的一系列解，构造出问题规模为I的解。这样，程序可从i=0或i=1出发，重复地，由已知至i-1规模的解，通过递推，获得规模为i的解，直至得到规模为N的解。
【问题】 阶乘计算
问题描述：编写程序，对给定的n（n&100），计算并输出k的阶乘k！（k=1，2，&，n）的全部有效数字。
由于要求的整数可能大大超出一般整数的位数，程序用一维数组存储长整数，存储长整数数组的每个元素只存储长整数的一位数字。如有m位成整数N用数组a[ ]存储：
N=a[m]&10m-1+a[m-1]&10m-2+ & +a[2]&101+a[1]&100
并用a[0]存储长整数N的位数m，即a[0]=m。按上述约定，数组的每个元素存储k的阶乘k！的一位数字，并从低位到高位依次存于数组的第二个元素、第三个元素&&。例如，5！=120，在数组中的存储形式为：
3 0 2 1 &&
首元素3表示长整数是一个3位数，接着是低位到高位依次是0、2、1，表示成整数120。
计算阶乘k！可采用对已求得的阶乘(k-1)！连续累加k-1次后求得。例如，已知4！=24，计算5！，可对原来的24累加4次24后得到120。细节见以下程序。
# include &stdio.h&
# include &malloc.h&
# define MAXN 1000
void pnext(int a[ ],int k)
{ int *b,m=a[0],i,j,r,
b=(int * ) malloc(sizeof(int)* (m+1));
for ( i=1;i&=m;i++) b[i]=a[i];
for ( j=1;j&=k;j++)
{ for ( carry=0,i=1;i&=m;i++)
{ r=(i&a[0]?a[i]+b[i]:a[i])+
a[i]=r%10;
carry=r/10;
if (carry) a[++m]=
void write(int *a,int k)
printf(&%4d！=&,k);
for (i=a[0];i&0;i--)
printf(&%d&,a[i]);
printf(&\n\n&);
void main()
{ int a[MAXN],n,k;
printf(&Enter the number n: &);
scanf(&%d&,&n);
write(a,1);
for (k=2;k&=n;k++)
{ pnext(a,k);
write(a,k);
getchar();
递归是设计和描述算法的一种有力的工具，由于它在复杂算法的描述中被经常采用，为此在进一步介绍其他算法设计方法之前先讨论它。
能采用递归描述的算法通常有这样的特征：为求解规模为N的问题，设法将它分解成规模较小的问题，然后从这些小问题的解方便地构造出大问题的解，并且这些规模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小问题的解构造出规模较大问题的解。特别地，当规模N=1时，能直接得解。
【问题】 编写计算斐波那契（Fibonacci）数列的第n项函数fib（n）。
斐波那契数列为：0、1、1、2、3、&&，即：
fib(n)=fib(n-1)+fib(n-2) （当n&1时）。
写成递归函数有：
int fib(int n)
{ if (n==0) return 0;
if (n==1) return 1;
if (n&1) return fib(n-1)+fib(n-2);
递归算法的执行过程分递推和回归两个阶段。在递推阶段，把较复杂的问题（规模为n）的求解推到比原问题简单一些的问题（规模小于n）的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是说，为计算fib(n)，必须先计算fib(n-1)和fib(n-2)，而计算fib(n-1)和fib(n-2)，又必须先计算fib(n-3)和fib(n-4)。依次类推，直至计算fib(1)和fib(0)，分别能立即得到结果1和0。在递推阶段，必须要有终止递归的情况。例如在函数fib中，当n为1和0的情况。
在回归阶段，当获得最简单情况的解后，逐级返回，依次得到稍复杂问题的解，例如得到fib(1)和fib(0)后，返回得到fib(2)的结果，&&，在得到了fib(n-1)和fib(n-2)的结果后，返回得到fib(n)的结果。
在编写递归函数时要注意，函数中的局部变量和参数知识局限于当前调用层，当递推进入&简单问题&层时，原来层次上的参数和局部变量便被隐蔽起来。在一系列&简单问题&层，它们各有自己的参数和局部变量。
由于递归引起一系列的函数调用，并且可能会有一系列的重复计算，递归算法的执行效率相对较低。当某个递归算法能较方便地转换成递推算法时，通常按递推算法编写程序。例如上例计算斐波那契数列的第n项的函数fib(n)应采用递推算法，即从斐波那契数列的前两项出发，逐次由前两项计算出下一项，直至计算出要求的第n项。
【问题】 组合问题
问题描述：找出从自然数1、2、&&、n中任取r个数的所有组合。例如n=5，r=3的所有组合为： （1）5、4、3 （2）5、4、2 （3）5、4、1
（4）5、3、2 （5）5、3、1 （6）5、2、1
（7）4、3、2 （8）4、3、1 （9）4、2、1
（10）3、2、1
分析所列的10个组合，可以采用这样的递归思想来考虑求组合函数的算法。设函数为void comb(int m,int k)为找出从自然数1、2、&&、m中任取k个数的所有组合。当组合的第一个数字选定时，其后的数字是从余下的m-1个数中取k-1数的组合。这就将求m个数中取k个数的组合问题转化成求m-1个数中取k-1个数的组合问题。设函数引入工作数组a[ ]存放求出的组合的数字，约定函数将确定的k个数字组合的第一个数字放在a[k]中，当一个组合求出后，才将a[ ]中的一个组合输出。第一个数可以是m、m-1、&&、k，函数将确定组合的第一个数字放入数组后，有两种可能的选择，因还未去顶组合的其余元素，继续递归去确定；或因已确定了组合的全部元素，输出这个组合。细节见以下程序中的函数comb。
# include &stdio.h&
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i&=k;i--)
comb(i-1,k-1);
{ for (j=a[0];j&0;j--)
printf(&%4d&,a[j]);
printf(&\n&);
void main()
comb(5,3);
回溯法也称为试探法，该方法首先暂时放弃关于问题规模大小的限制，并将问题的候选解按某种顺序逐一枚举和检验。当发现当前候选解不可能是解时，就选择下一个候选解；倘若当前候选解除了还不满足问题规模要求外，满足所有其他要求时，继续扩大当前候选解的规模，并继续试探。如果当前候选解满足包括问题规模在内的所有要求时，该候选解就是问题的一个解。在回溯法中，放弃当前候选解，寻找下一个候选解的过程称为回溯。扩大当前候选解的规模，以继续试探的过程称为向前试探。
【问题】 组合问题
问题描述：找出从自然数1，2，&，n中任取r个数的所有组合。
采用回溯法找问题的解，将找到的组合以从小到大顺序存于a[0]，a[1]，&，a[r-1]中，组合的元素满足以下性质：
（1） a[i+1]&a[i]，后一个数字比前一个大；
（2） a[i]-i&=n-r+1。
按回溯法的思想，找解过程可以叙述如下：
首先放弃组合数个数为r的条件，候选组合从只有一个数字1开始。因该候选解满足除问题规模之外的全部条件，扩大其规模，并使其满足上述条件（1），候选组合改为1，2。继续这一过程，得到候选组合1，2，3。该候选解满足包括问题规模在内的全部条件，因而是一个解。在该解的基础上，选下一个候选解，因a[2]上的3调整为4，以及以后调整为5都满足问题的全部要求，得到解1，2，4和1，2，5。由于对5不能再作调整，就要从a[2]回溯到a[1]，这时，a[1]=2，可以调整为3，并向前试探，得到解1，3，4。重复上述向前试探和向后回溯，直至要从a[0]再回溯时，说明已经找完问题的全部解。按上述思想写成程序如下：
# define MAXN 100
int a[MAXN];
void comb(int m,int r)
{ int i,j;
if (a[i]-i&=m-r+1
{ if (i==r-1)
{ for (j=0;j&r;j++)
printf(&%4d&,a[j]);
printf(&\n&);
{ if (i==0)
} while (1)
{ comb(5,3);
贪婪法是一种不追求最优解，只希望得到较为满意解的方法。贪婪法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪婪法不要回溯。
例如平时购物找钱时，为使找回的零钱的硬币数最少，不考虑找零钱的所有各种发表方案，而是从最大面值的币种开始，按递减的顺序考虑各币种，先尽量用大面值的币种，当不足大面值币种的金额时才去考虑下一种较小面值的币种。这就是在使用贪婪法。这种方法在这里总是最优，是因为银行对其发行的硬币种类和硬币面值的巧妙安排。如只有面值分别为1、5和11单位的硬币，而希望找回总额为15单位的硬币。按贪婪算法，应找1个11单位面值的硬币和4个1单位面值的硬币，共找回5个硬币。但最优的解应是3个5单位面值的硬币。
【问题】 装箱问题
问题描述：装箱问题可简述如下：设有编号为0、1、&、n-1的n种物品，体积分别为v0、v1、&、vn-1。将这n种物品装到容量都为V的若干箱子里。约定这n种物品的体积均不超过V，即对于0&i＜n，有0＜vi&V。不同的装箱方案所需要的箱子数目可能不同。装箱问题要求使装尽这n种物品的箱子数要少。
若考察将n种物品的集合分划成n个或小于n个物品的所有子集，最优解就可以找到。但所有可能划分的总数太大。对适当大的n，找出所有可能的划分要花费的时间是无法承受的。为此，对装箱问题采用非常简单的近似算法，即贪婪法。该算法依次将物品放到它第一个能放进去的箱子中，该算法虽不能保证找到最优解，但还是能找到非常好的解。不失一般性，设n件物品的体积是按从大到小排好序的，即有v0&v1&&&vn-1。如不满足上述要求，只要先对这n件物品按它们的体积从大到小排序，然后按排序结果对物品重新编号即可。装箱算法简单描述如下：
{ 输入箱子的容积；
输入物品种数n；
按体积从大到小顺序，输入各物品的体积；
预置已用箱子链为空；
预置已用箱子计数器box_count为0；
for (i=0;i&n;i++)
{ 从已用的第一只箱子开始顺序寻找能放入物品i 的箱子j；
if （已用箱子都不能再放物品i）
{ 另用一个箱子，并将物品i放入该箱子；
box_count++；
将物品i放入箱子j；
上述算法能求出需要的箱子数box_count，并能求出各箱子所装物品。下面的例子说明该算法不一定能找到最优解，设有6种物品，它们的体积分别为：60、45、35、20、20和20单位体积，箱子的容积为100个单位体积。按上述算法计算，需三只箱子，各箱子所装物品分别为：第一只箱子装物品1、3；第二只箱子装物品2、4、5；第三只箱子装物品6。而最优解为两只箱子，分别装物品1、4、5和2、3、6。
若每只箱子所装物品用链表来表示，链表首结点指针存于一个结构中，结构记录尚剩余的空间量和该箱子所装物品链表的首指针。另将全部箱子的信息也构成链表。以下是按以上算法编写的程序。
# include &stdio.h&
# include &stdlib.h&
typedef struct ele
struct ele *
typedef struct hnode
Struct hnode *
void main()
{ int n, i, box_count, box_volume, *a;
HNODE *box_h, *box_t, *j;
ELE *p, *q;
Printf(&输入箱子容积\n&);
Scanf(&%d&,&box_volume);
Printf(&输入物品种数\n&);
Scanf(&%d&,&n);
A=(int *)malloc(sizeof(int)*n);
Printf(&请按体积从大到小顺序输入各物品的体积：&);
For (i=0;i&n;i++) scanf(&%d&,a+i);
Box_h=box_t=NULL;
Box_count=0;
For (i=0;i&n;i++)
{ p=(ELE *)malloc(sizeof(ELE));
for (j=box_h;j!=NULL;j=j-&next)
if (j-&remainder&=a[i])
if (j==NULL)
{ j=(HNODE *)malloc(sizeof(HNODE));
j-&remainder=box_volume-a[i];
j-&head=NULL;
if (box_h==NULL) box_h=box_t=j;
else box_t=boix_t-&next=j;
j-&next=NULL;
box_count++;
else j-&remainder-=a[i];
for (q=j-&q!=NULL&&q-&link!=NULL;q=q-&link);
if (q==NULL)
{ p-&link=j-&
j-&head=p;
{ p-&link=NULL;
q-&link=p;
printf(&共使用了%d只箱子&，box_count);
printf(&各箱子装物品情况如下：&);
for (j=box_h,i=1;j!=NULL;j=j-&next,i++)
{ printf(&第%2d只箱子，还剩余容积%4d，所装物品有；\n&,I,j-&remainder);
for (p=j-&p!=NULL;p=p-&link)
printf(&%4d&,p-&vno+1);
printf(&\n&);
任何一个可以用计算机求解的问题所需的计算时间都与其规模N有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算；n=2时，只要作一次比较即可排好序；n=3时只要作3次比较即可，&。而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。
分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
如果原问题可分割成k个子问题（1&k&n），且这些子问题都可解，并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。
分治法所能解决的问题一般具有以下几个特征：
（1）该问题的规模缩小到一定的程度就可以容易地解决；
（2）该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；
（3）利用该问题分解出的子问题的解可以合并为该问题的解；
（4）该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
上述的第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；第二条特征是应用分治法的前提，它也是大多数问题可以满足的，此特征反映了递归思想的应用；第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑贪心法或动态规划法。第四条特征涉及到分治法的效率，如果各子问题是不独立的，则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。
分治法在每一层递归上都有三个步骤：
（1）分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
（2）解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；
（3）合并：将各个子问题的解合并为原问题的解。
6.动态规划法
经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。
为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。以下先用实例说明动态规划方法的使用。
【问题】 求两字符序列的最长公共字符子序列
问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=&x0，x1，&，xm-1&，序列Y=&y0，y1，&，yk-1&是X的子序列，存在X的一个严格递增下标序列&i0，i1，&，ik-1&，使得对所有的j=0，1，&，k-1，有xij=yj。例如，X=&ABCBDAB&，Y=&BCDB&是X的一个子序列。
考虑最长公共子序列问题如何分解成子问题，设A=&a0，a1，&，am-1&，B=&b0，b1，&，bm-1&，并Z=&z0，z1，&，zk-1&为它们的最长公共子序列。不难证明有以下性质：
（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且&z0，z1，&，zk-2&是&a0，a1，&，am-2&和&b0，b1，&，bn-2&的一个最长公共子序列；
（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵&z0，z1，&，zk-1&是&a0，a1，&，am-2&和&b0，b1，&，bn-1&的一个最长公共子序列；
（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵&z0，z1，&，zk-1&是&a0，a1，&，am-1&和&b0，b1，&，bn-2&的一个最长公共子序列。
这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找&a0，a1，&，am-2&和&b0，b1，&，bm-2&的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出&a0，a1，&，am-2&和&b0，b1，&，bn-1&的一个最长公共子序列和找出&a0，a1，&，am-1&和&b0，b1，&，bn-2&的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。
代码如下：
# include &stdio.h&
# include &string.h&
# define N 100
char a[N],b[N],str[N];
int lcs_len(char *a, char *b, int c[ ][ N])
{ int m=strlen(a), n=strlen(b), i,j;
for (i=0;i&=m;i++) c[i][0]=0;
for (i=0;i&=n;i++) c[0][i]=0;
for (i=1;i&=m;i++)
for (j=1;j&=m;j++)
if (a[i-1]==b[j-1])
c[i][j]=c[i-1][j-1]+1;
else if (c[i-1][j]&=c[i][j-1])
c[i][j]=c[i-1][j];
c[i][j]=c[i][j-1];
return c[m][n];
char *buile_lcs(char s[ ],char *a, char *b)
{ int k, i=strlen(a), j=strlen(b);
k=lcs_len(a,b,c);
s[k]=&\0&;
while (k&0)
if (c[i][j]==c[i-1][j]) i--;
else if (c[i][j]==c[i][j-1]) j--;
else { s[--k]=a[i-1];
void main()
{ printf (&Enter two string（&%d）!\n&,N);
scanf(&%s%s&,a,b);
printf(&LCS=%s\n&,build_lcs(str,a,b));
迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为f(x)=0，用某种数学方法导出等价的形式x=g(x)，然后按以下步骤执行：
（1） 选一个方程的近似根，赋给变量x0；
（2） 将x0的值保存于变量x1，然后计算g(x1)，并将结果存于变量x0；
（3） 当x0与x1的差的绝对值还小于指定的精度要求时，重复步骤（2）的计算。
若方程有根，并且用上述方法计算出来的近似根序列收敛，则按上述方法求得的x0就认为是方程的根。上述算法用C程序的形式表示为：
程序如下：
【算法】迭代法求方程组的根
for (i=0;i&n;i++)
x[i]=初始近似根;
for (i=0;i&n;i++)
y[i] = x[i];
for (i=0;i&n;i++)
x[i] = gi(X);
for (delta=0.0,i=0;i&n;i++)
if (fabs(y[i]-x[i])&delta) delta=fabs(y[i]-x[i])；
} while (delta&Epsilon)；
for (i=0;i&n;i++)
printf(&变量x[%d]的近似根是 %f&，I，x[i])；
printf(&\n&)；
具体使用迭代法求根时应注意以下两种可能发生的情况：
（1）如果方程无解，算法求出的近似根序列就不会收敛，迭代过程会变成死循环，因此在使用迭代算法前应先考察方程是否有解，并在程序中对迭代的次数给予限制；
（2）方程虽然有解，但迭代公式选择不当，或迭代的初始近似根选择不合理，也会导致迭代失败。
8.穷举搜索法
穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并从众找出那些符合要求的候选解作为问题的解。
【问题】 将A、B、C、D、E、F这六个变量排成如图所示的三角形，这六个变量分别取[1，6]上的整数，且均不相同。求使三角形三条边上的变量之和相等的全部解。如图就是一个解。
程序引入变量a、b、c、d、e、f，并让它们分别顺序取1至6的整数，在它们互不相同的条件下，测试由它们排成的如图所示的三角形三条边上的变量之和是否相等，如相等即为一种满足要求的排列，把它们输出。当这些变量取尽所有的组合后，程序就可得到全部可能的解。程序如下：
# include &stdio.h&
void main()
int a,b,c,d,e,f;
for (a=1;a&=6;a++)
for (b=1;b&=6;b++)
for (c=1;c&=6;c++)
if (c==a)||(c==b)
for (d=1;d&=6;d++)
if (d==a)||(d==b)||(d==c)
for (e=1;e&=6;e++)
if (e==a)||(e==b)||(e==c)||(e==d)
f = 21-(a+b+c+d+e);
if ((a+b+c==c+d+e))&&(a+b+c==e+f+a))
printf(&%6d,a);
printf(&%4d%4d&,b,f);
printf(&%2d%4d%4d&,c,d,e);
scanf(&%*c&);
按穷举法编写的程序通常不能适应变化的情况。如问题改成有9个变量排成三角形，每条边有4个变量的情况，程序的循环重数就要相应改变。
阅读(...) 评论()