编程之美学习心得 二 （未完待续）

2.1 求二进制数中1的个数

     解法一：暴力的解法

          对N中二进制1的个数：N = b[0] +b[1]*2+b[2]*2^2+...b[n]*2^n

          

          int count（BYTE v）{

               int num = 0 ;

               while(v)

               {

                    if(v%2==1){

                         num++;

                    }

                    v>>1;

               }

               return num;

          }

     解法二：位操作

          如果该二进制最后位上为1，与0x01相与，结果为1；然后将二进制右移

          int count(BYTE v)

          {

               int num = 0;

               while(v)

               {

                    num += v&0x01 ;

                    v>>1;

               }

               return num;

          }

     解法三：v &（v-1）

          int count(BYTE v){

               int num = 0;

               while(v){

                    v = v&(v-1);

                    sum ++;

               }

               return sum;

          }

     解法四：使用分支 （利用空间换取时间）

              利用switch case语句，将每个数字的1的个数设置好，直接返回。

               实际执行效率可能会低于方法二和三。具体要看分支执行情况。

     方法五：查表法

               提前将每个数1的个数放到一个表中，直接读取这个数组。

2.2 求N！中末尾0的个数  和二进制表示中最低位1的位置。

     解法1：最直接的解法是找出能是末尾为0的那些数，通过分析N！=(2^x)*(3^y)*(5^z).....

                    由于只有2*5=10，才能是末尾为0；由于N！ 中2的个数远多于5，所以找0的个数实际上是找N！分解5的个数。

               int ret = 0;

               for(i=1;i<=N;i++)

               {

                    j=i;

                    while(j%5==0){

                         ret++;

                         j/=5;

                    }

               }

     解法2：Z= [N/5]+[N/5^2]+[N/5^3]+...   总会存在k使得[N/5^k]=0;

               [N/5]所有小于等于N的数中5的倍数贡献一个5

               [N/5^2]所有不大于N的书中5^2的倍数贡献一个5

               

               int ret=0;

               while(N){

                    ret += N/5;

                    N/=5;

                25         ...20.... 15  14  13  12  11  10  9  8  7  6  5  4  3  2  1 

N/5:          1              1        1                         1                  1

N/5^2        1

25!中包含6个5因子。故有6个0；

求二进制中最低位1的位置，需要确定二进制末尾有多少个0；由于一个数*2，其二进制向左移移位，0的个数即N!中包含多少个2因子。

解法1：             

  result = [N/2]+[N/2^2]+[N/2^3]+... 

          

          int lowestOne(int N){

               int ret = 0 ;

               while(N){

                    

                    N>>1;

                    ret += N;

               }

               return ret;

          }

解法2：

N！中因子2的个数=N-N中二进制1的数目。

假设N=11011；

N!中2因子的个数count =  [N/2]+[N/2^2]+[N/2^3]+... 

                                 =  1101 +110+11+1

                                 =  (1000+100+1)+(100+10)+(10+1)+1

                                 =  (1111)+(111)+1

                                 = (10000-1)+(1000-1)+(10-1)+(1-1)

                                = 11011 - N中1的个数

给定数N判断是否为2的方幂   n>0&&n&(n-1)==0

2.3 寻找发帖王水

          找出那个ID号出现次数超过总数一半的ID。

     通常做法是：先将所有ID排序，然后遍历ID统计ID出现的次数，找超过一般次数的ID。

     对于已经有序的ID，则不需要对ID进行遍历，取N/2处的ID即是所找的ID。

     有没有一种不需要排序就能找出王水的ID的方法？

     每次取两个不同的ID，那么剩下的ID中王水出现的次数仍超过一半。从而不断的重复这个过程，直到找到答案。

     Type Find(Type *ID,int N)

     {

          Type candidate;

          int nTimes,i;

          for(i=0; i<N;i++){

               if(nTimes==0){

                    candidate = ID[i];

                    nTimes =1;

               }

               esle{

                    if(candidate == ID[i]){

                         nTimes ++;

                    }else{

                         nTimes--;

                    }

               }

          }

          return candidate;

      }

2.4 1的个数   写下1到N所有数中1的个数

    设N= 12013，计算百位上1的个数的数字有百位数字、百位以上数字和百位一下数字决定。

     12013如果百位数字为0；则百位数字为1的情况有100-199、1100-1199、……、11100-11199一共有12*100=1200个；

     12113如果百位数字为1：则百位数字为1的情况有100-199、1100-1199、……、11100-11199、12100-12113一共有12*100+13+1=1214；

     12313如果百位数字为其他：则百位数字为1的情况有100-199、1100-1199、……、11100-11199、12100-12199一共有（12+1）*100=1300；

     所以需要计算当前位的值，低位的值，高位的值，

      LONGLONG  Sum1s (  ULONGLONG  n  )

{

        ULONGLONG  iCount  =0;

        ULONGLONG  iFactor  =1;

        ULONGLONG  iLowerNum  =0;

        ULONGLONG  iCurrentNum  =0;

        ULONGLONG  iHighNum  =0;

        while ( n  / iFactor  !=0){

              iLowerNum  =  n  - n /  iFactor * iFactor  ;

              iCurrentNum = n  / iFactor %10;

              iHighNum  =  n  /( iFactor *10);

              switch  ( iCurrentNum  )

            {

              case  0:

                    iCount  +=  iHighNum  * iFactor ;

                    break ;

              case  1:

                    iCount  +=  iHighNum  * iFactor  +  iLowerNum +1;

                    break ;

              case  2:

                    iCount  += ( iHighNum  +1)* iFactor ;

                    break ;

            }

              iFactor  *= 10;

      }

       return   iCount   ;   

}

2.5 寻找最大k个数

解法1：  排序 取前k个数  复杂度O(N*logN)+o(k)

解法2：  快排中的第一步，将待排数分成两组，其中一组的任意一个数比另外一组任意数要大，在对两个分组做类似的操作。。。

          假设有数组S，从S中中随机找到一个元素x，把数组分成两部分Sa和Sb。Sa中的元素大于X，Sb中的元素小于X。这时：

     1. Sa中的元素个数小于K，Sa中所有元素和Sb中最大的K-|Sa|个元素

     2. Sa中的元素个数大于等于K，则需要直接返回Sa中最大的K个数。

方法4：利用最大堆最小堆。湘江K个元素放在最小堆中，每次新加入一个元素X，如果X比堆顶元素小，则不考虑，反之，将该元素替换堆顶元素，更新最小堆。时间复杂度为O(nlogK)

方法5： 利用桶排序，对于N个数取值范围有限，统计每个数出现的次数用数组count(MaxN)记录，从最大的数的个数取出大于K个数为止。

2.6 精确的表示浮点数

对于有限小数或者无限循环小数都可以转化为分数来存储。

例如：0.9= 9/10

          1.333(3) = 1/3

对于有限小数X= 0.A1A2A3...An=A1A2...An/10^n

对于无限循环小数  X=0.A1A2A3...An(B1B2B3..Bm)

                   10^n*X=A1A2...An.(B1B2...Bm)

                              =A1A2..An+0.B1B2...Bm(B1B2...Bm) = A1A2...An +Y

    Y= 0.B1B2...Bm(B1B2...Bm) 

10^m*Y = B1B2...Bm+0.B1B2...Bm(B1B2...Bm)=B1B2...Bm+Y

Y=B1B2...Bm/(10^m-1)

X = (A1A2...An+B1B2..Bm/(10^m-1))/10^n

剩下的问题是找出分子和分母的最大公约数进行约分，求出最简分数。求最大公约数参考下一节。

2.7 最大公约数问题

f(x,y)=x,y的最大公约数，取k=x/y;b=x%y;则x=ky+b;（x>=Y）

 如果一个数可以被x，y同时整除，则这个数必将可以被y，b整除，

f(x,y)=f(y,b)=f(y,x%y);

对于大整数来说，模运算带来的开销比较大，由于x，y的约数一定是x-y,y的约数，

f(x,y) = f(x-y,y)

BigInt gcd(Bigint X,BigInt Y){

     if(x<y)

          return gcd(y,x);

     if(y==0)

          return x;

     else

          return gcd (x-y,y)

}

但对于大整数来说，减法带来运算次数的开销比较大，尤其是gcd（10000000,1）这种情况。

对于x，y来说，如果x= kx1，y=ky1；则f(x,y)=k*f(x1,y1);

如果x=px1，p是素数，y%p！=0；则f（x,y）= f(x1,y);

对算法的改进：

     取p=2；

当x，y都是偶数，f（x,y）=2*f(x>>1,y>>1)

当x为偶数，y为奇数，f(x,y)=f(x>>1,y)

当x为奇数，y为偶数，f（x,y）=f(x,y>>1);

当x,y都是奇数，f(x,y)=f(x-y,y)

BigInt gcd(BigInt x,BigInt y){

     if(x<y)

          return gcd(y,x);

     if(y==0)

          return x;

     else

     {

          if(IsEven(x)){

               if(IsEven(y)){

                    return gcd(x,y-x);

               }else{

                    return gcd(x,y>>1);

               }

          }else{

               if(IsEven(y)){

                    return gcd(x>>1,y);

               }

                else{

                    return 2*gcd(x>>1,y>>1);

               }

          }

     }

 }

2.9 Fibonacci数列

F(n) = 0   n=0

       = 1     n=1

       = F(n-1) + F(n-1)  n>1

一般解法：

     int Fibonacci(int n){

          if(n==0)

               return 0;

          else if(n==1){

               return 1;

          }else

               return Fibonacci(n-1) + Fibonacci(n-2);

     }   

在递归调用时通过数组记录已经计算过的值，这样以空间换取时间，时间复杂度为O(n)。

解法2： 求解通项公式

          F(n)=F(n-1)+F(n-2)

特征方程为X^2=X +1

有根：X = (1+5^0.5)/2   X=(1-5^0.5)/2

F(n)=A*X1^n+B*X2^n

由F(0) = 0,F(1)=1;==>A=5^0.5/5   B=-A

由于引入了无理数，不能保证精度。

解法三：分治的方法

     （F(n) F(n-1)） = (F(n-1)  F(n-2))*A

==> A=1   1

            1   0

(Fn  Fn-1) = (Fn-1  Fn-2)A =...  = (F1  F0)A^(n-1)

A^(x*2) = (A^x)^2

用二进制表示n：

     n=b0 +b1*2 +b2*2*2 +...+bk*2^k

A^n = A^(b0 +b1*2 +b2*2*2 +...+bk*2^k)

      = A^b0*(A^2)b1*(A^(2^2))^b2*...*(A^(2^k))^bk

所以求 A^(2^k) = (A^(2^(k-1)))^2

class Matrix;

Matrix MatrixPow(Const Matrix &m,int n)

{

      Matirx result = Matrix::Identity;//单位阵

     Matrix tmp= m;

     for(;n;n>>1){

          if(n&1){

               result *= tmp;

          }

          tmp *=tmp;

     }

}

int Fabonacci(int n){

     Matrix an = MatrixPow(A,n-1);

     return F0*an(0,0) +F1*an(1,0);

}

2.10 寻找数组中的最大值和最小值

解法1：穷举，找出数组中最大值和最小值，时间复杂度为2*N次，O(N);

解法2：将数组中的数按相邻两个放在一组，比较每组中较大的放在偶数位，较小的放在奇数位，需要N/2次比较

          从偶数中比较选出最大的那个即为最大值，需要N/2次比较；

          从奇数中比较选出较小的那个即为最小值，需要N/2次比较；总共需要1.5N次比较。

解法三：解法二破坏了原来数组的顺序，解法三是不破坏数组的顺序的。

     利用两个变量max和min分别记录最大值和最小值，通过相邻的两个比较，去除较大的放在max中，取出较小的放在min中，然后再比较下两个数，将较小的与min比较，将较大的与max比较。

解法四：利用分治的思想，在前N/2和后N/2中分别找出一个min和max，然后去较小的min和较大max

          f(N)=2f(N/2)+2

               =2*(2*f(N/2^2)+2))+2

               =2^2*f(N/2^2)+2^2+2

               =2^(logN-1)*f(N/2^(logN-1))+2^logN+...+2^2+2

               =N/2*f(2)+2*(1-2(logN-1))/(1-2)

               =N/2+N-2

               =1.5N-2

2.11 寻找最近点对

方法1 穷举  计算两两之间点的距离，比较它们求出最小值，时间复杂度为O(N*N)；

方法2：对于数组有序，找最小的差值就容易了，快排的时间复杂度O(nlogn)，找最小差值需要O(n）；总的时间复杂度为O(nlogn)

方法3：分治的思想，去数组的中间数，将数字分成left和right两部分，分别找出left和right中的最小差值，然后和来自left的一个数和来自right的一个数的差值比较去最小值。时间复杂度O(nlogn)

     对于平面二维的情况；将平面上的点映射到x轴上，去这些点的中点将这些点分成left和right两部分，并找出left中的最小值和right中最小值。取MDist=min（MinDist_right,MinDist_Right）；取矩形区域MDist*2MDist，比较这个区域中的点中最小距离，因为在这个区域外的点在left和right间的距离肯定大于MDist，每次找两个区域间最短路径的时间消耗为O(N)，二分法的时间复杂度为O(logN)；总的时间复杂度为O(nlogn).

2.12 快速找满足条件的两个数

方法1：穷举法，计算两两数字之和是否满足条件 时间复杂度为O(n*n)

方法2：对于arr[i],判断另一个数字sum-arr[i]是否在数组中。

     对于一个无序的数组查找一个数的复杂度为O(N)，对于arr[i]中n个数的查找复杂度O(N*N)

     

     另一个思路是先将数组排序，在利用二分查找复杂度为O(logN)；快排的复杂度O(nlogN)；总体时间复杂度依然为O(nlogn)

     然而，还有一种快速查找hash表，直接可以查找某个数是否存在，查找复杂度为O(1)；这样对于N个数总体的复杂度为O(N);

解法三：

     先排序，时间复杂度为O(nlogn)；在排序的基础上，从前后遍历一次，令i=0；j=n-1;判断arr[i]+arr[j]时候=sum，若相等，则结束，

若小于sum，则i++；若大于sum，则j--;

     for（i=0,j=n-1; i<j;）{

          if(arr[i]+arr[j]==sum){

               return (i,j);

          }else if(arr[i]+arr[j]<sum){

               i++;

          }else{

               j++;

          }

     }

return (-1,-1);