与数字相关算法

丑数

问题描述：

我们把只包含因子（因子都是质数，合数不叫做因子）2、3、5的数称为丑数，如6、8都是丑数，14不是丑数，因为14包含因子7，习惯上1也是丑数。求出1到1500之间的所有丑数。

思路：

解法一： 逐个判断是不是丑数，时间复杂度比较大

从丑数的定义可知，如果一个数是丑数，那么该数一定能被2、3、5整除，故判断一个数m是不是丑数，可以通过执行下面操作来完成：

while(m%2==0){m /= 2;}

while(m%3==0){m /= 3;}

while(m%5==0){m /= 5;}

如果最后得出的m等于1，则原来的m是丑数，否则不是丑数。

怎么证明？假如最后的值为n，只要能证明n是一个质数（则n本身是m的一个因子，而n不等于2、3、5）或者n包含除2、3、5以外的因子：

假如n是一个质数，则m便是丑数

假如n是合数，那么n可以表示为若干个质数的积，如果这些质数包含了2、3、5，那么在之前的循环中已经被除去了，所以合数n必然包含了出2、3、5以外的因子，那么m自然也就包含除2、3、5以外的因子了。

知道怎么判断一个数是不是丑数，那么可以通过逐个判断来求1到1500之间的所有丑数。

解法二： 通过已知的丑数，求后面剩余的丑数，避免对非丑数的计算，用空间换时间

假如，已知有序的丑数1、2、3、5、7，怎么求下一个丑数？

有规则如：

丑数乘以2、3或5得到的一定也是丑数，而任一个丑数也一定可以由另一个丑数乘以2、3或5得到。

所以，求下一个 最小 丑数，可以通过前面的丑数乘以2、3或5（注意不能是乘以多个，如m*2*3，那在其之前就有m*2和m*3了，所以就直接用(m*2)*3或(m*3)*2便可，不需要乘以多个）。

所有的有可能的下一 最小 丑数：

前面出现的所有丑数（已经保存在数组中）分别乘以2，然后取其中一个最小的且大于数组中最大的一个（数组的最后一个，因为数组是有序的），如，已出现的丑数为：1、2、3、5、7，那可以求的2、4、6、10、14，由于10是比7大的最小一个，所以取10。

同理求乘以3和乘以5的情况，如，已出现的丑数为1、2、3、5、7，乘以3对应的是3、6、9、15、21，取9，乘以5对应的是5、10、15、25、35，取10。

然后取三者中的最小作为下一个最小丑数，这里是9,。为什么取最小，因为较大可以通过重复以上操作来求得。

由于数组本身有序，故在求乘2（乘3或乘5）的候选丑数时，可以通过二分法，如上面的1、2、3、5、7，我们可以先求3*2，得到6，由于6<7，不满足，再进一步对5、7二分，求5*2，得到10，10>7，但可能还存在比10小且比7大的数，故还要进一步二分，直到无法二分为止，这里要对5的左边3的右边部分二分，由于已经没有数了，故到此为止，所以候选值为10。同理，也通过二分求乘3和乘5的候选值。

---

随机生成和为S的N个正整数——投影法 

以生成和为20的4个数为例，可以先生成随机生成0到20之间的三个数字再排序，假设得到了4，7，18。然后在X-Y数轴上画出这三个数，如下图：

然后将这些数值投影到Y轴上，可得下图：

由图很容易看出AB，BC，CD，DE这四段的长度和肯定为20。因此AB，BC，CD，DE这四段的长度即和为20的4个数，这4个数分别为4，3，11，2。这种方法只要随机生成N - 1个小于S的不同数字，排序后计算两两差值就可以得到和为S的N个正整数。

C++实现：

#include<cstdio>

#include<ctime>

#include<set>

#include<algorithm>

usingnamespace std;

//在[s, e)区间上随机取n个不同的数并存放到a[]中

void GetRandomNum(int *a, intn, ints, inte)

{

    set<int> set_a;

    srand(time(0));

    for (int i = 0; i < n; i++)

    {

        int num = (rand() % (e-s)) + s;

        if (set_a.find(num) == set_a.end())

            set_a.insert(num);

        else

            i--;

    }

    int i = 0;

    set<int>::iterator pos;

    for (pos = set_a.begin(); pos != set_a.end(); pos++)

        a[i++] = *pos;

}

int main()

{

    constint NSUM = 20;

    constint NCOUNT = 4;

    printf("生成和为%d的%d个数 \n", NSUM, NCOUNT);

    int a[NCOUNT];

    GetRandomNum(a, NCOUNT - 1, 10, NSUM);

    sort(a, a + NCOUNT - 1);

    a[NCOUNT - 1] = NSUM;

    printf("已经生成和为%d的%d个数: \n", NSUM, NCOUNT);

    printf("%d ", a[0]);

    for (int i = 1; i < NCOUNT; i++)

        printf("%d ", a[i] - a[i - 1]);

    putchar('\n');

    return 0;

}

---

n个骰子的点数

问题：

n个骰子的点数之和s，求s的所有可能的值及其出现的概率

思路：

用一个数组A保存s出现的次数，A[s]表示和为s的值出现的次数，假如有n个骰子，那么数组的大小为6n，算上A[0]，那么数组大小为6n+1，因为所有骰子都为6的时候和最大，最大的和便是6n。

数组A的初始时每个元素的值都为0，我们逐个骰子往里面加：

首先加入第一个骰子，则A[0]=0、A[1]=1、A[2]=1、A[3]=1、A[4]=1、A[5]=1、A[6]=1、A[7]=0、A[8]=0。。。

然后加入第二个骰子，我们从坐标为2*6=12的位置开始向前修改数组的值，因为坐标大于12的元素都不受影响，依旧是0，怎么求新的A[s]的值呢？因为新加进来的骰子的值只能从1到6，假设其为i，要想和为s，那么原来骰子的和要是s-i，原来骰子的和为s-i出现的次数为A[s-i]，则有当新骰子为i时，总骰子和为s出现的次数为A[s-i]，由于新骰子可以从1到6，所以：

A[s]=A[s-1]+A[s-2]+A[s-3]+A[s-4]+A[s-5]+A[s-6]

加入第二个骰子时，我们需要修改A[12]到A[1]的值

加入第三个骰子时，需要修改A[18]到A[2]的值

依次类推

C实现（windows）：

#include<stdio.h>

double * func(intn, intmaxValue)

{

    if (n< = 0 || maxValue <= 0)

        returnNULL;

    int size = maxValue * n + 1;

    //用于存放和出现的次数

    int * sumArray = (int *)malloc(size * sizeof(int));

    //初始化数组

    for (int i = 0; i < size; i++)

    {

        sumArray[i] = 0;

    }

    //加入第一个骰子

    for (int i = 1; i <= maxValue; i++)

    {

        sumArray[i] = 1;

    }

    //逐个加入骰子

    for (int i = 2; i <= n; i++)

    {

        for (int j = i * maxValue; j >= i - 1; j--)

        {

            sumArray[j] = 0;

            for (int k = 1; k <= maxValue; k++)

            {

                if (j - k <= i - 2)

                    break;

                sumArray[j] += sumArray[j - k];

            }

        }

    }

    //用于存放和出现的概率

    double * probabilitiesArray = (double *)malloc((size + 1) * sizeof(double));

    //和出现的总次数，可以通过求sumArray数组的和得到，也可以通过排列数得到

    int sum = 1;

    for (int i = 0; i < n; i++)

        sum *= maxValue;

    for (int i = 0; i < size; i++)

    {

        /*

        double除以int得double，int除以double也得double，(double)sumArray[i]/sum，

        C会先将sumArray[i]转换成double，然后再除以sum，得到的是double，故小数部分不会丢失，

        如果改成(double)(sumArray[i]/sum)虽然结果被转换成了double，但转换之前的结果是int，

        小数部分已经丢失了

        */

        probabilitiesArray[i] = (double)sumArray[i] / sum;

    }

    free(sumArray);

    probabilitiesArray[size] = -1;

    return probabilitiesArray;

}

int main()

{

    double * result = func(3, 6);

    for (int i = 1;; i++)

    {

        if (result[i] == -1)

            break;

        printf("%d,%f\n", i, result[i]);

    }

   free(result);

}

maxValue用于设置一个骰子的面数，当然，默认情况下一个骰子有6面，为了使函数更具通用性，这里允许设置骰子的面数

---

求1+2+3+4+....+n

问题：

求1+2+3+4+....+n，要求不能使用乘除法、for、while、，if、else、switch及(A?B:C)

解法一：利用函数指针实现递归

C实现：

#include<stdio.h>

//定义一个函数指针

typedefint(*fun)(int);

int method1(intn)

{

    return 0;

}

int method2(intn)

{

    fun f[2] = { method1, method2 };

    return f[!!n](n-1) + n;

}

int main()

{

    int result = method2(5);

    printf("%d", result);

}

说明：

!!n：当n非零时 ， 对n连续做两次反运算得到true，C/C++里面true与1是等价的，当n为零时，对n连续做两次反运算得到false，C/C++里false与0等价。

method2实际上是一个递归，因为当n不为0时，都变成执行f[1](n-1)+n，即method2(n-1)+n，当n为0时，调用f[0](n)，即method1(n)来结束递归。

解法二：利用构造函数实现循环

C++实现： 因为C没有类

#include<iostream>

usingnamespace std;

classTemp

{

public:

    Temp(){ ++n; sum += n; }

    staticvoid Reset(){ n = 0; sum = 0; }

    staticint GetSum(){ return sum; }

private:

    staticint n;

    staticint sum;

};

int method(intn)

{

    Temp::Reset();

    Temp *a = newTemp[n];

    delete[]a;

    a = NULL;

    returnTemp::GetSum();

}

void main()

{

    int sum = method(5);

    cout<< sum << endl;

}

说明：

method中创建一个大小为n的数组，会调用Temp构造函数n次，每调用一次Temp构造函数便执行一次相加，结果保存在静态变量中，因而每次调用都共享这个静态结果。

注意：

如果换成Java便不可行，因为Java创建数组的时候构造函数不会被调用：

class SuperClass{

   public SuperClass(){

      System.out.println("SuperClass构造函数被调用");

   }

}

publicclass Test {

    publicstaticvoid main(String[]args){

       SuperClass[]sup = new SuperClass[5];

    }

}

以上代码不会有任何输出

解法三：利用虚函数实现递归

C++实现：

#include<iostream>

usingnamespace std;

classA;

A * Array[2];

classA

{

public:

    virtualint sum(intn){ return 0; }

};

classB :publicA

{

public:

    int sum(intn)

    {

        return Array[!!n]->sum(n - 1) + n;

    }

};

int method(intn)

{

    A a;

    B b;

    Array[0] =& a;

    Array[1] =& b;

    int value = Array[1]->sum(n);

    return value;

}

void main()

{

    int sum = method(5);

    cout<< sum << endl;

}

---

求素数(质数)

问题：

给定正整数参数 N，求小于 N的质数，从小到大打印出来

思路：

解法一：

分别判断1到N，判断n是否为质数，可以分别用n除以2到(n-1)的每个数，都不能整除则n为质数，该解法时间复杂度为O(N^2)。

解法二：

除了2以外，所有的质数一定是奇数，所以不需要从1到N逐个判断，只要判断3到N的所有奇数便可，也就是循环时不再用for(int n= 1;n<=N;n++)，而是用for(int n = 3;n<=N;n+=2)。解法二比解法一减少了一半的运算量。

解法三：

n如果是非质数，那么n一定有一个小于等于n/2的质因子，证明：

假设n=x*y，因为x>=2，所以y<=n/2，怎么证明"质因子"？假设y是质数，则可证，假设y不是质数，则y有两个因子，即y=a*b，如果a或b是质数，则可证，否则进一步对a或b求因子，这样直到找到一个质数因子为止，为什么算法一定会结束？因为每次分解后的因子都小于等于分解前的一半，所以算法总会结束。

这样的话，试除的时候就不必从2到(n-1)，只要从2到(n/2)便可，所以时间复杂度又减少了一半。还可以进一步优化，只要除以2到(n/2)的质数便可，而我们在求n之前的质数时，已经把这些质数保存起来了，所以不必从2到(n/2)，可以从保存起来的质数数组或链表中去取，取出来后与n/2比较一下，只比较小于等于n/2的便可。

解法四：

如果n是非质数，则n一定有小于等于根号n的质因子，证明：

假设n=x*y，假设x>=根号n，则y<=根号n，进一步对y分解，最终一定找到一个质因子。

所以，只要试除根号n以内的质数便可，这样一来时间复杂度进一步减少了。