C++博客-mengkai-随笔分类-algorithmhttp://www.cppblog.com/mengkai/category/17832.htmlzh-cnSat, 26 May 2012 04:29:11 GMTSat, 26 May 2012 04:29:11 GMT60装载 从决策树学习谈到贝叶斯分类算法、EM、HMM http://www.cppblog.com/mengkai/archive/2012/05/21/175628.htmlmengkaimengkaiMon, 21 May 2012 12:14:00 GMThttp://www.cppblog.com/mengkai/archive/2012/05/21/175628.htmlhttp://www.cppblog.com/mengkai/comments/175628.htmlhttp://www.cppblog.com/mengkai/archive/2012/05/21/175628.html#Feedback0http://www.cppblog.com/mengkai/comments/commentRss/175628.htmlhttp://www.cppblog.com/mengkai/services/trackbacks/175628.html阅读全文

mengkai 2012-05-21 20:14 发表评论
]]>一个关于递归相当的斐波那契数列的各种解法http://www.cppblog.com/mengkai/archive/2011/10/26/159141.htmlmengkaimengkaiWed, 26 Oct 2011 09:46:00 GMThttp://www.cppblog.com/mengkai/archive/2011/10/26/159141.htmlhttp://www.cppblog.com/mengkai/comments/159141.htmlhttp://www.cppblog.com/mengkai/archive/2011/10/26/159141.html#Feedback0http://www.cppblog.com/mengkai/comments/commentRss/159141.htmlhttp://www.cppblog.com/mengkai/services/trackbacks/159141.html对于斐波那契数列的求解过程的几种方法的比较
（1）最基本的方法：递归实现，使用公式为f[n] = f[n-1] + f[n-2];递归

结束条件是f[1]=1，f[2]=1。
（2）数组实现：空间复杂度和时间复杂度都是O（N），效率一般，比递归来

的快。
（3）vector<int>实现，时间复杂度是O(N)，空间复杂度O(1)，但是不知道

效率会高不高，当然vector有自己的属性会占用资源。
（4）queue<int>实现，当然队列数组更适合实现斐波那契数列，时间复杂度

和空间复杂度和vector一样。但是queue太合适这里了，
f(n)=f(n-1)+f(n-2)，f(n)只和f(n-1)和f(n-2)有关，f(n)入队列后，f(n-

2)就可以出队列了。
（5）迭代实现：迭代效率最高，时间复杂度是O(N)，空间复杂度是O(1)，
（6）百度的提供的一种公式法。   由于double类型的精度还不够，所以程

序算出来的结果会有误差，如果把公式展开计算，得出的结果就是正确的。

具体代码如下：
//递归
int fib1(int num)
{
if(num<1)
return  -1;
if(num == 1 || num == 2)
return 1;
return f(n-1)+f(n-2);
}

//数组实现
int fib2(int num)
{
if(num<1)
return  -1;
if(num<3)
{
return 1;
}
int *a = new int[num];
a[0] = a[1] = 1;
for(int i = 2;i<num;i++)
a[i] = a[i-1] + a[i-2];
int ret = a[num-1];
delete[] a;
return ret;
}

//vector<int>
int fib3(int num)
{
if(num<1)
return  -1;
vector<int>a(2,1);
a.reserve(3);
for(int i = 2;i<num;i++)
{
a.insert(a.begin(),a.at(0)+a.at(1));
a.pop_back();
}
return a.at(0);
}

//queue<int>实现
int fib4(int num)
{
if(num<1)
return  -1;
queue<int>q;
q.push(1);
q.push(1);
for(int i = 2;i<num;i++)
{
q.push(q.front()+q.back());
q.pop();
}
return q.pop();
}

//迭代实现
int fib5(int num)
{
int i,a=1,b = 1,c = 1;
if(num<1)
return  -1;
for(i = 2;i<num;i++)
{
c= a + b;
a = b;
b = c;
}
return c;
}


//公式实现
int fib6(int num)
{
double gh = sqrt((double)5);
return pow(1+(1+gh),n-pow(1-gh))/(pow((double)2,n)*gh);
}


mengkai 2011-10-26 17:46 发表评论
]]>这几天看了一些关于递归的算法，现在我也自己写个关于递归的总结，http://www.cppblog.com/mengkai/archive/2011/10/22/158889.htmlmengkaimengkaiSat, 22 Oct 2011 13:22:00 GMThttp://www.cppblog.com/mengkai/archive/2011/10/22/158889.html递归的最简单应用：通过各项关系及初值求数列的某一项。
（1）

比如阶乘数列

1、2、6、24、120、720……

如果用上面的方式来描述它，应该是：

，程序实现
int fun(int x)
{
   if(x == 1)
   return 1;
   return n*fun(n-1);
}
(2)找出组合数
找出从自然数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个组合，我们可以采用递归来实现，假设函数为combo(int m,int n);为找到自然数1-m中任取K个数组合，当第一个数选定后，后面的k-1个数是从m-1各数中选择得到。我们发现这将是将m选k个数转换为m-1个数中选k-1个数的组合数。为了解决此问题，我们可以定义个数组A，数组的第一个元素为k，约定函数将确定的k个数字的组合第一个数放在A[k]中，当一个组合求出后，才将数组A的一个组合输出，第一个数可以是m-k，函数将确定组合的第一个数放入数组后，有两种可能的选择，因还未到顶组合的其余元素，继续递归确定，或因一确定了组合的全部元素，输出这个组合，
具体代码：
//递归求解组合数
#define  MAX 100
int a[MAX];
void combo(int m,int k)
{
 int i,j;
 for (i = m;i>=k;i--)
 {
  a[k] = i;
  if (k>1)
  {
   comb(m-1,k-1);
  }
  else
  {
   for (j = a[0];j>0;j--)
   {
    printf("%4d",a[j]);
   }
   printf("\n");
  }
 }
}

更多的练习，

前几天在博客园看到有人面试时，遇到递归算法题，一时手痒就解了一个。顺便网上又找来几个，也实现了。给大家分享一下，开阔一下思路，没准你明天面试就能用上。

1、编写一个方法用于验证指定的字符串是否为反转字符，返回true和false。请用递归算法实现。（反转字符串样式为"abcdedcba"）

2、一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30个是多少

3、一列数的规则如下: 1、12、123、1234、12345、123456......,求第n个数的递归算法（n<=9）。

4、将一整数逆序，如987654321变为123456789。

5、一个射击运动员打靶,靶一共有10环,连开10枪打中90环的可能行有多少种?




mengkai 2011-10-22 21:22 发表评论
]]> 程序员面试100题之八：不要被阶乘吓倒http://www.cppblog.com/mengkai/archive/2011/09/29/157133.htmlmengkaimengkaiThu, 29 Sep 2011 05:51:00 GMThttp://www.cppblog.com/mengkai/archive/2011/09/29/157133.htmlhttp://www.cppblog.com/mengkai/comments/157133.htmlhttp://www.cppblog.com/mengkai/archive/2011/09/29/157133.html#Feedback0http://www.cppblog.com/mengkai/comments/commentRss/157133.htmlhttp://www.cppblog.com/mengkai/services/trackbacks/157133.html对于阶乘是个很有意思的函数，给定一个整数，那么它的阶乘是多少那？而它末尾有多少个0，
对于这个问题，是不是要直接计算N!？如果溢出怎么办，我们如何快速的找到该题的结果？首先要思考的N!= M*10^E。在N之前你需要看看那几个的成绩满足即可，比如2*5=10，所有2和5乘积就可以得到一个10，于是由于能被2整除的整数的频率要高于能被5整除的，所以我们可以取5考即可。
方法一从1开始到N，算出符合要求的个数。int result=0;
for(i = 1;i<=N;i++)
{
   j = i;
   while(j%5 == 0)
   {
      result++;//统计N的阶乘中那些能够被5整除的因子的个数  
      j/5;
   }
}
或者是while(N)
{
   result+=N/5;
   N/=5;
}

类似可以求解二进制的问题，比如求N!的二进制中最低位1的位置。
由于N!中含有质数2的个数。等于N/2+N/4+N/8....1.
int lowOfone(int n)
{
int result = 0;
while (n)

{
n>>=1;
result+=n;
}
return result;
}
对于给定整数n，判断它是否为2的方幂（解答提示：n>0&&（（n&（n-1））==0））。

转载：
【N!二进制的解法二】

N！含有质因数2的个数，还等于N减去N的二进制表示中1的数目。我们还可以通过这个规律来求解。

下面对这个规律进行举例说明，假设 N = 11011，那么N!中含有质因数2的个数为 N/2 + N/4 + N/8 + N/16 + …

即： 1101 + 110 + 11 + 1

=（1000 + 100 + 1）

+（100 + 10）

+（10 + 1）

+ 1

=（1000 + 100+ 10 + 1）+（100 + 10 + 1）+ 1

= 1111 + 111 + 1

=（10000 -1）+（1000 - 1）+（10-1）+（1-1）

= 11011-N二进制表示中1的个数

小结
任意一个长度为m的二进制数N可以表示为N = b[1] + b[2] * 2 + b[3] * 22 + … + b[m] * 2(m-1)，其中b [ i ]表示此二进制数第i位上的数字（1或0）。所以，若最低位b[1]为1，则说明N为奇数；反之为偶数，将其除以2，即等于将整个二进制数向低位移一位。





mengkai 2011-09-29 13:51 发表评论
]]>