精华内容
下载资源
问答
  • 一个文明可以比较顺利地发展出计数方法和加减法运算,但要想创造一套简单可行的乘法运算方法却不那么容易。我们目前使用的乘法竖式计算看似简便,实际上这需要我们事先掌握九九乘法口诀表;考虑到这一点,这种竖式...
    
    			

        在各种文明的算术发展过程中,乘法运算的产生是很重要的一步。一个文明可以比较顺利地发展出计数方法和加减法运算,但要想创造一套简单可行的乘法运算方法却不那么容易。我们目前使用的乘法竖式计算看似简便,实际上这需要我们事先掌握九九乘法口诀表;考虑到这一点,这种竖式计算并不是完美的。我们即将看到,在数学的发展过程中,不同的文明创造出了哪些不同的乘法运算方法,其中有的运算法甚至可以完全抛弃乘法表。
        古巴比伦数学使用60进制,考古发现的一块古巴比伦泥板证实了这一点。这块泥板上有一个正方形,对角线上有四个数字1, 24, 51, 10。最初发现这块泥板时人们并不知道这是什么意思,后来某牛人惊讶地发现,如果把这些数字当作60进制的三位小数的话,得到的正好是单位正方形对角线长度的近似值:1 + 24/60 + 51/60^2 + 10/60^3 = 1.41421296296...  这说明古巴比伦已经掌握了勾股定理。60进制的使用为古巴比伦数学的乘法运算发展带来了很大的障碍,因为如果你要背59-59乘法口诀表的话,至少也得背1000多项,等你把它背完了后我期末论文估计都已经全写完了。另一项考古发现告诉了我们古巴比伦数学的乘法运算如何避免使用乘法表。考古学家们发现一些泥板上刻有60以内的平方表,利用公式ab = [(a+b)^2 - a^2 - b^2]/2 可以迅速查表得到ab的值。另一个公式则是ab = [(a+b)^2 - (a-b)^2]/4,这说明两个数相乘只需取它们的和平方与差平方的差,再两次取半即可。平方数的频繁使用很可能加速了古巴比伦人发现勾股定理的过程。
        古巴比伦数学把除以一个数看作是乘以它的倒数,利用倒数表可以很方便的实现这种算法。倒数表开头的一部分是这个样子:


    2      0; 30
    3      0; 20
    4      0; 15
    5      0; 12
    6      0; 10
    8      0; 7, 30
    9      0; 6, 40
    10     0; 6
    12     0; 5
    15     0; 4
    16     0; 3, 45
    18     0; 3, 20
    20     0; 3
    ....    ....


        
        古巴比伦人很早就发现,1/7是一个无限小数,怎么除也除不完。古巴比伦的倒数表里所有的数都是精确的小数,它们(在60进制中)都是有限小数。碰到无限小数时,他们会用取近似值的方法来解决。例如,古巴比伦人会通过1/13 = 1*(1/13) = 7*(1/91) ≈ 7*(1/90) = 7*(40/3600) = (7*40)/3600 来计算1/13的值。那个40就是查倒数表查出来的。


        古埃及数学使用了完全不同的乘法运算法。它们的乘法运算不需要借助任何辅助用表。古埃及人注意到,任何一个数都可以表示为若干个不同的2的幂的和。因此,你需要做的仅仅是不断将1和乘数进行翻倍。看看古埃及人如何计算46乘以22:

      46 x 22 = 1012
       1   22
       2   44     44
       4   88   + 88
       8  176  + 176
      16  352
      32  704  + 704
              -------
                1012


        上面的演算中,左列是1不断翻倍的结果,右边是22不断翻倍的结果。选出左列的2, 4, 8, 32,它们的和正好就是被乘数46;那么把右列对应的数加起来就是乘法运算的最终结果。至于如何选出2, 4, 8, 32这四个数,一个简单的方法就是,不断选出左列里小于被乘数的数中最大的一个,然后当前被乘数减去它。比如,32是最大的数,用46-32后剩14;8是小于14的最大数,14-8后剩6;然后最大的小于6的数是4,6减去4后剩2,这样下来2+4+8+32正好就是被乘数46了。这其实就是二进制的经典应用,2, 4, 8, 32正好与46的二进制中的数字1一一对应。你可以在这里看到一些相关的东西。
        无独有偶,据说俄国农村曾产生过这样一种乘法算术法:将被乘数逐次减半,同时乘数依次加倍,那么找出所有左边的数是奇数的行,其右列的数的和就是答案。例如,下面的例子中,23, 11, 5和1都是奇数,于是右边对应的44, 88, 176和704的和就是乘法运算的结果。这个做法与古埃及的算术法完全一样,但看起来似乎更神奇一些。

      46 x 22 = 1012
      46   22
      23   44     44
      11   88   + 88
       5  176  + 176
       2  352
       1  704  + 704
              -------
                1012


    做人要厚道
    转贴请注明出处

    展开全文
  • 算法简单说是算术方法小学我们学的加减法的竖式计算乘法的小九九它们可以解决加减乘这几类计算都是算法广义上说算法就是做某一类事的步骤例如菜谱做菜的算法棋谱下棋的算法歌谱唱歌的算法手机说明书操作手机的算法在...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    第1章 声明和初始化 ...6.23 sizeof返回大小是以字节计算的怎样才能判断数组中有多少个元素呢? 第7章 内存分配 基本内存分配问题 7.1 为什么这段代码不行?char*answer;printf("Typesomething...
  • 快速幂(Exponentiation by squaring,平方求幂)是一种简单而有效小算法,它可以以时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。让我们先来思考一个问题:710次方,怎样算...

    aa0c1a5b8210dcaf0d54d9f02b904bc4.png

    快速幂(Exponentiation by squaring,平方求幂)是一种简单而有效的小算法,它可以以1510c9f9-c72d-eb11-8da9-e4434bdf6706.svg的时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。

    让我们先来思考一个问题:7的10次方,怎样算比较快?

    方法1:最朴素的想法,7*7=49,49*7=343,... 一步一步算,共进行了9次乘法。

    这样算无疑太慢了,尤其对计算机的CPU而言,每次运算只乘上一个个位数,无疑太屈才了。这时我们想到,也许可以拆分问题。

    方法2:先算7的5次方,即7*7*7*7*7,再算它的平方,共进行了5次乘法。

    但这并不是最优解,因为对于“7的5次方”,我们仍然可以拆分问题。

    方法3:先算7*7得49,则7的5次方为49*49*7,再算它的平方,共进行了4次乘法。

    模仿这样的过程,我们得到一个在 1510c9f9-c72d-eb11-8da9-e4434bdf6706.svg 时间内计算出幂的算法,也就是快速幂。


    递归快速幂

    刚刚我们用到的,无非是一个二分的思路。我们很自然地可以得到一个递归方程:

    1710c9f9-c72d-eb11-8da9-e4434bdf6706.svg

    计算a的n次方,如果n是偶数(不为0),那么就先计算a的n/2次方,然后平方;如果n是奇数,那么就先计算a的n-1次方,再乘上a;递归出口是a的0次方为1

    递归快速幂的思路非常自然,代码也很简单(直接把递归方程翻译成代码即可):

    //递归快速幂int qpow(int a, int n)
    {
    if (n == 0)
    return 1;
    else if (n % 2 == 1)
    return qpow(a, n - 1) * a;
    else
    {
    int temp = qpow(a, n / 2);
    return temp * temp;
    }
    }

    注意,这个temp变量是必要的,因为如果不把1a10c9f9-c72d-eb11-8da9-e4434bdf6706.svg记录下来,直接写成qpow(a, n /2)*qpow(a, n /2),那会计算两次1a10c9f9-c72d-eb11-8da9-e4434bdf6706.svg,整个算法就退化为了 1d10c9f9-c72d-eb11-8da9-e4434bdf6706.svg 。

    在实际问题中,题目常常会要求对一个大素数取模,这是因为计算结果可能会非常巨大,但是在这里考察高精度又没有必要。这时我们的快速幂也应当进行取模,此时应当注意,原则是步步取模,如果MOD较大,还应当开long long

    //递归快速幂(对大素数取模)#define MOD 1000000007typedef long long ll;
    ll qpow(ll a, ll n)
    {
    if (n == 0)
    return 1;
    else if (n % 2 == 1)
    return qpow(a, n - 1) * a % MOD;
    else
    {
    ll temp = qpow(a, n / 2) % MOD;
    return temp * temp % MOD;
    }
    }

    大家知道,递归虽然简洁,但会产生额外的空间开销。我们可以把递归改写为循环,来避免对栈空间的大量占用,也就是非递归快速幂

    非递归快速幂

    我们换一个角度来引入非递归的快速幂。还是7的10次方,但这次,我们把10写成二进制的形式,也就是 1e10c9f9-c72d-eb11-8da9-e4434bdf6706.svg 。

    现在我们要计算 1f10c9f9-c72d-eb11-8da9-e4434bdf6706.svg ,可以怎么做?我们很自然地想到可以把它拆分为 2010c9f9-c72d-eb11-8da9-e4434bdf6706.svg . 实际上,对于任意的整数,我们都可以把它拆成若干个 2110c9f9-c72d-eb11-8da9-e4434bdf6706.svg 的形式相乘。而这些2110c9f9-c72d-eb11-8da9-e4434bdf6706.svg,恰好就是 2510c9f9-c72d-eb11-8da9-e4434bdf6706.svg 、2710c9f9-c72d-eb11-8da9-e4434bdf6706.svg2810c9f9-c72d-eb11-8da9-e4434bdf6706.svg……我们只需不断把底数平方就可以算出它们。

    我们先看代码,再来仔细推敲这个过程:

    //非递归快速幂int qpow(int a, int n){
    int ans = 1;
    while(n){
    if(n&1) //如果n的当前末位为1 ans *= a; //ans乘上当前的a a *= a; //a自乘 n >>= 1; //n往右移一位 }
    return ans;
    }

    最初ans为1,然后我们一位一位算:

    1010的最后一位是0,所以a^1这一位不要。然后1010变为101,a变为a^2。

    101的最后一位是1,所以a^2这一位是需要的,乘入ans。101变为10,a再自乘。

    10的最后一位是0,跳过,右移,自乘。

    然后1的最后一位是1,ans再乘上a^8。循环结束,返回结果。

    aa0c1a5b8210dcaf0d54d9f02b904bc4.png

    这里的位运算符,>>是右移,表示把二进制数往右移一位,相当于/2;&是按位与,&1可以理解为取出二进制数的最后一位,相当于%2==1。这么一等价,是不是看出了递归和非递归的快速幂的关系了?虽然非递归快速幂因为牵扯到二进制理解起来稍微复杂一点,但基本思路其实和递归快速幂没有太大的出入。


    快速幂的拓展

    上面所述的都是整数的快速幂,但其实,在算 2c10c9f9-c72d-eb11-8da9-e4434bdf6706.svg 时,只要a的数据类型支持乘法满足结合律,快速幂的算法都是有效的。矩阵、高精度整数,都可以照搬这个思路。下面给出一个模板:

    //泛型的非递归快速幂template <typename T>
    T qpow(T a, ll n)
    {
    T ans = 1; // 赋值为乘法单位元,可能要根据构造函数修改 while (n)
    {
    if (n & 1)
    ans = ans * a; // 这里就最好别用自乘了,不然重载完*还要重载*=,有点麻烦。 n >>= 1;
    a = a * a;
    }
    return ans;
    }

    注意,较复杂类型的快速幂的时间复杂度不再是简单的 1510c9f9-c72d-eb11-8da9-e4434bdf6706.svg ,它与底数的乘法的时间复杂度有关。

    例如,矩阵快速幂的一个经典应用是求斐波那契数列:

    (洛谷P1962) 斐波那契数列

    题目背景
    大家都知道,斐波那契数列是满足如下性质的一个数列:3010c9f9-c72d-eb11-8da9-e4434bdf6706.svg题目描述
    请你求出 3210c9f9-c72d-eb11-8da9-e4434bdf6706.svg 的值。

    (以下内容涉及到基本的线性代数知识)

    设矩阵 3310c9f9-c72d-eb11-8da9-e4434bdf6706.svg ,我们有3410c9f9-c72d-eb11-8da9-e4434bdf6706.svg,于是 :

    3510c9f9-c72d-eb11-8da9-e4434bdf6706.svg

    这样,我们把原来较为复杂的问题转化成了求某个矩阵的幂的问题,这就可以应用快速幂求解了。

    #include #define MOD 1000000007typedef long long ll;struct matrix
    {
    ll a1, a2, b1, b2;
    matrix(ll a1, ll a2, ll b1, ll b2) : a1(a1), a2(a2), b1(b1), b2(b2) {}
    matrix operator*(const matrix &y)
    {
    matrix ans((a1 * y.a1 + a2 * y.b1) % MOD,
    (a1 * y.a2 + a2 * y.b2) % MOD,
    (b1 * y.a1 + b2 * y.b1) % MOD,
    (b1 * y.a2 + b2 * y.b2) % MOD);return ans;
    }
    };
    matrix qpow(matrix a, ll n)
    {
    matrix ans(1, 0, 0, 1); //单位矩阵 while (n)
    {if (n & 1)
    ans = ans * a;
    a = a * a;
    n >>= 1;
    }return ans;
    }int main()
    {
    ll x;
    matrix M(0, 1, 1, 1);
    scanf("%lld", &x);
    matrix ans = qpow(M, x - 1);
    printf("%lld\n", (ans.a1 + ans.a2) % MOD);return 0;
    }
    展开全文
  • 快速幂(Exponentiation by squaring,平方求幂)是一种简单而有效小算法,它可以以时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。让我们先来思考一个问题:710次方,怎样...

    6d5f05692d744fd6d2f46cfaf5668c2b.png

    快速幂Exponentiation by squaring,平方求幂)是一种简单而有效的小算法,它可以以

    的时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。

    让我们先来思考一个问题:7的10次方,怎样算比较快?

    方法1:最朴素的想法,7*7=49,49*7=343,... 一步一步算,共进行了9次乘法。

    这样算无疑太慢了,尤其对计算机的CPU而言,每次运算只乘上一个个位数,无疑太屈才了。这时我们想到,也许可以拆分问题。

    方法2:先算7的5次方,即7*7*7*7*7,再算它的平方,共进行了5次乘法。

    但这并不是最优解,因为对于“7的5次方”,我们仍然可以拆分问题。

    方法3:先算7*7得49,则7的5次方为49*49*7,再算它的平方,共进行了4次乘法。

    模仿这样的过程,我们得到一个在

    时间内计算出幂的算法,也就是快速幂。

    递归快速幂

    刚刚我们用到的,无非是一个二分的思路。我们很自然地可以得到一个递归方程:

    计算a的n次方,如果n是偶数(不为0),那么就先计算a的n/2次方,然后平方;如果n是奇数,那么就先计算a的n-1次方,再乘上a;递归出口是a的0次方为1

    递归快速幂的思路非常自然,代码也很简单(直接把递归方程翻译成代码即可):

    //递归快速幂
    int qpow(int a, int n)
    {
        if (n == 0)
            return 1;
        else if (n % 2 == 1)
            return qpow(a, n - 1) * a;
        else
        {
            int temp = qpow(a, n / 2);
            return temp * temp;
        }
    }
    

    注意,这个temp变量是必要的,因为如果不把

    记录下来,直接写成qpow(a, n /2)*qpow(a, n /2),那会计算两次
    ,整个算法就退化为了

    在实际问题中,题目常常会要求对一个大素数取模,这是因为计算结果可能会非常巨大,但是在这里考察高精度又没有必要。这时我们的快速幂也应当进行取模,此时应当注意,原则是步步取模,如果MOD较大,还应当开long long

    //递归快速幂(对大素数取模)
    #define MOD 1000000007
    typedef long long ll;
    ll qpow(ll a, ll n)
    {
        if (n == 0)
            return 1;
        else if (n % 2 == 1)
            return qpow(a, n - 1) * a % MOD;
        else
        {
            ll temp = qpow(a, n / 2) % MOD;
            return temp * temp % MOD;
        }
    }
    

    大家知道,递归虽然简洁,但会产生额外的空间开销。我们可以把递归改写为循环,来避免对栈空间的大量占用,也就是非递归快速幂

    非递归快速幂

    我们换一个角度来引入非递归的快速幂。还是7的10次方,但这次,我们把10写成二进制的形式,也就是

    现在我们要计算

    ,可以怎么做?我们很自然地想到可以把它拆分为
    . 实际上,对于任意的整数,我们都可以把它拆成若干个
    的形式相乘。而这些
    ,恰好就是
    ……我们只需
    不断把底数平方就可以算出它们。

    我们先看代码,再来仔细推敲这个过程:

    //非递归快速幂
    int qpow(int a, int n){
        int ans = 1;
        while(n){
            if(n&1)        //如果n的当前末位为1
                ans *= a;  //ans乘上当前的a
            a *= a;        //a自乘
            n >>= 1;       //n往右移一位
        }
        return ans;
    }
    

    最初ans为1,然后我们一位一位算:

    1010的最后一位是0,所以a^1这一位不要。然后1010变为101,a变为a^2。

    101的最后一位是1,所以a^2这一位是需要的,乘入ans。101变为10,a再自乘。

    10的最后一位是0,跳过,右移,自乘。

    然后1的最后一位是1,ans再乘上a^8。循环结束,返回结果。

    e6ea22cfe11db1e175f39187cecd3217.png

    这里的位运算符,>>是右移,表示把二进制数往右移一位,相当于/2;&是按位与,&1可以理解为取出二进制数的最后一位,相当于%2==1。这么一等价,是不是看出了递归和非递归的快速幂的关系了?虽然非递归快速幂因为牵扯到二进制理解起来稍微复杂一点,但基本思路其实和递归快速幂没有太大的出入。


    快速幂的拓展

    上面所述的都是整数的快速幂,但其实,在算

    时,只要a的数据类型支持
    乘法满足结合律,快速幂的算法都是有效的。矩阵、高精度整数,都可以照搬这个思路。下面给出一个模板:
    //泛型的非递归快速幂
    template <typename T>
    T qpow(T a, ll n)
    {
        T ans = 1; // 赋值为乘法单位元,可能要根据构造函数修改
        while (n)
        {
            if (n & 1)
                ans = ans * a; // 这里就最好别用自乘了,不然重载完*还要重载*=,有点麻烦。
            n >>= 1;
            a = a * a;
        }
        return ans;
    }
    

    注意,较复杂类型的快速幂的时间复杂度不再是简单的

    ,它与底数的乘法的时间复杂度有关。

    例如,矩阵快速幂的一个经典应用是求斐波那契数列:

    (洛谷P1962) 斐波那契数列

    题目背景
    大家都知道,斐波那契数列是满足如下性质的一个数列:
    题目描述
    请你求出
    的值。

    (以下内容涉及到基本的线性代数知识)

    设矩阵

    ,我们有
    ,于是 :

    这样,我们把原来较为复杂的问题转化成了求某个矩阵的幂的问题,这就可以应用快速幂求解了。

    #include <cstdio>
    #define MOD 1000000007
    typedef long long ll;
    
    struct matrix
    {
        ll a1, a2, b1, b2;
        matrix(ll a1, ll a2, ll b1, ll b2) : a1(a1), a2(a2), b1(b1), b2(b2) {}
        matrix operator*(const matrix &y)
        {
            matrix ans((a1 * y.a1 + a2 * y.b1) % MOD,
                       (a1 * y.a2 + a2 * y.b2) % MOD,
                       (b1 * y.a1 + b2 * y.b1) % MOD,
                       (b1 * y.a2 + b2 * y.b2) % MOD);
            return ans;
        }
    };
    
    matrix qpow(matrix a, ll n)
    {
        matrix ans(1, 0, 0, 1); //单位矩阵
        while (n)
        {
            if (n & 1)
                ans = ans * a;
            a = a * a;
            n >>= 1;
        }
        return ans;
    }
    
    int main()
    {
        ll x;
        matrix M(0, 1, 1, 1);
        scanf("%lld", &x);
        matrix ans = qpow(M, x - 1);
        printf("%lldn", (ans.a1 + ans.a2) % MOD);
        return 0;
    }
    

    Pecco:算法学习笔记(目录)zhuanlan.zhihu.com
    429e5e02bc8ca26f183bce64d1fe8fa6.png
    展开全文
  • 1.36 我总算弄清楚函数指针声明方法了,但怎样才能初始化呢? 20 1.37 能够初始化联合吗? 20 第2章 结构、联合和枚举 21 结构声明 21 2.1 struct x1{ };和typedef struct{ }x2; 有什么不同? 21 2.2...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.36 我总算弄清楚函数指针声明方法了,但怎样才能初始化呢? 20 1.37 能够初始化联合吗? 20 第2章 结构、联合和枚举 21 结构声明 21 2.1 struct x1{ };和typedef struct{ }x2; 有什么不同? 21 2.2...
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    1.14 我总算弄清除函数指针声明方法了, 但怎样才能初始化呢? . . 5 2 结构、联合和枚举7 2.1 声明struct x1 f . . . g; 和typedef struct f . . . g x2; 有什么不同? . 7 2.2 为什么struct x f . . . g; x ...
  • 简单解释:很像一个计算器,我输入两个数字,然后按加号你就给我计算和,我按乘法你就给我计算乘积,内部算法客户端不关注,我就告诉你我想做怎样的计算,你去给我计算吧!和工厂方法有一点像, 应用场景:立马就...

    策略模式:定义了不同的算法,分别封装起来,让他们可以互相替换,即使算法变化了,也不会影响到使用算法的用户;

    简单解释:很像一个计算器,我输入两个数字,然后按加号你就给我计算和,我按乘法你就给我计算乘积,内部算法客户端不关注,我就告诉你我想做怎样的计算,你去给我计算吧!和工厂方法有一点像,

    应用场景:立马就想到解除多个if else if 的场景了

    //定义策略,提供一个方法供具体策略俩实现
    public abstract class Strategy {
        public abstract void  calculate();
    }
    
    // 具体算法开始实现
    public class StrategyAA extends Strategy {
        @Override
        public void calculate() {
            System.out.println("实现算法A");
        }
    }
    public class StrategyBB extends Strategy {
        @Override
        public void calculate() {
            System.out.println("实现算法B");
        }
    }
    
    //用一个context类来维护对抽象算法类Strategy对象的引用
    public class Context {
        Strategy strategy;
        public Context(Strategy strategy){
            this.strategy = strategy;
        }
    
        public void doWork(){
            strategy.calculate();
        }
    }

    开始测试:

    public class Test1 {
        public static void main(String[] args) {
            Context context = null;
            context = new Context(new StrategyAA());
            context.doWork();
    
            context = new Context(new StrategyBB());
            context.doWork();
        }
    }

    但是从上面测试类1的代码我们发现是在客户端判断是用什么算法,现在我们想把这个判断交由其他类处理,于是就有了下面的策略模式与简单工厂结合的方法。

    public class Context2 {
        Strategy strategy = null;
    
        public  Context2(String type){
            switch (type){
                case "A": strategy = new StrategyAA();
                break;
                case "B": strategy = new StrategyBB();
                break;
    
            }
        }
        public void ContrxtInterface(){
            strategy.AlgorithmInterface();
        }
    }
    //或者
    public class Context2 {
        static Map<String, Strategy> operationMap = new HashMap<>();
        static {
            operationMap.put("A", new StrategyAA());
            operationMap.put("B",  new StrategyBB());
        }
        public Context2(String type){
             strategy = operationMap.get(type);
        }
        public void doWork(){
            strategy.calculate();
        }
    }
    
    
    public class Text2 {
        public static void main(String[] args) {
            Context2 context2A = new Context2("A");
            context2A.doWork();
            Context2 context2B = new Context2("B");
            context2B.doWork();
        }
    }

     

     

     

     

     

    展开全文
  • 算法笔记【5】 快速幂

    万次阅读 2021-01-24 23:55:52
    快速幂(Exponentiation by squaring,平方求幂)是一种简单而有效小算法,它可以以Ologn时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。 让我们先来思考一个问题:710次方...
  • 快速幂

    2020-11-06 11:59:57
    (Exponentiation by squaring,平方求幂)是一种简单而有效小算法,它可以以[公式]时间复杂度计算乘方。快速幂不仅本身非常常见,而且后续很多算法也都会用到快速幂。 让我们先来思考一个问题:710次方,怎样...
  • o 2.14 我总算弄清除函数指针声明方法了, 但怎样才能初始化呢? * 3. 结构、联合和枚举 o 3.1 声明 struct x1 { ...}; 和 typedef struct { ...} x2; 有什么不同? o 3.2 为什么 struct x { ...}; x ...
  • 接着详细讲解了算法在排序、查找、数学计算、数论、历史趣题、游戏等领域中应用;后梳理和精选了一些经典算法面试题,供读者开拓思维之用。 第1章 算法和实现算法Java语法 1.1 建立算法初步概念 1.1.1 什么...
  • java自学之道

    2014-01-05 20:17:04
    第0章 JDK安装和最简单的环境变量配置方法 第1章 Java基础概念 一、 Java基础语法 1、Helloworld.java 2、标识符 3、关键字 4、常量 5、变量 6、语句 6.1 if语句和switch语句 6.1.2 if语句举例 6.1.3 switch语句 ...
  • Java程序员面试宝典pdf

    热门讨论 2013-02-21 13:06:13
    面试题170 怎样实现简单工厂模式编程 313 面试题171 怎样实现工厂方法模式编程 315 面试题172 怎样实现抽象工厂方法模式编程 317 面试题173 怎样实现观察者模式编程 319 面试题174 用Java实现一个链表类 323 15.3 小...
  • 面试题170 怎样实现简单工厂模式编程 313 面试题171 怎样实现工厂方法模式编程 315 面试题172 怎样实现抽象工厂方法模式编程 317 面试题173 怎样实现观察者模式编程 319 面试题174 用Java实现一个链表类 323 ...
  • 039 简单的文本编辑器 040 文件字数统计程序 041 学生成绩管理程序 第二部分 数据结构篇 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 ...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    “软件投入生产性运行以后需要的维护工作并不多,而且维护是一件很容易做的简单工作” 软件危机的解决 解决途径 组织管理 工程项目管理方法 技术措施 软件开发技术与方法 软件工具 软件工程概念 软件工程的概念 ...
  • 039 简单的文本编辑器 040 文件字数统计程序 041 学生成绩管理程序 第二部分 数据结构篇 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 049 基数排序 050 二叉搜索...
  • 039 简单的文本编辑器 040 文件字数统计程序 041 学生成绩管理程序 第二部分 数据结构篇 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 049 基数排序...
  • 039 简单的文本编辑器 040 文件字数统计程序 041 学生成绩管理程序 第二部分 数据结构篇 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 049 基数排序...
  •  书中以具体实例为线索,特别注重对例题分析、对知识点归纳、对求解方法的引申,同时程序代码中融会了c语言各种编程技巧,条理清晰,以方便读者举一反三,开发出符合特定要求程序。本书配套光盘中涵盖...
  • 6.3.1 Java语言中随机方法 167 6.3.2 [0,1]之间均匀分布随机数算法 169 6.3.3 产生任意范围随机数 170 6.3.4 [m,n]之间均匀分布随机整数算法 171 6.3.5 正态分布随机数生成算法 173 6.4 复数运算 ...

空空如也

空空如也

1 2
收藏数 38
精华内容 15
关键字:

怎样计算乘法的简单方法