BY adminWeb前端Posted on Leave a Comment on 小白详细解说高速幂–杭电oj2035-A^B
小白详细解说高速幂–杭电oj2035-A^B

不用循环和递归

其实这道题真心有好多种思路，计算指数之类的对数学系学霸们完全不是问题嘛：

版本2

JavaScript

const log4 = Math.log(4); function isPowerOfFour(num){ var n =
Math.log(num) / log4; return n === (0|n); }

1
2
3
4
5
const log4 = Math.log(4);
function isPowerOfFour(num){
    var n = Math.log(num) / log4;
    return n === (0|n);
}

嗯，通过对数公式 logm(n) = log(n) / log(m)
求出指数，然后判断指数是不是一个整数，这样就可以不用循环和递归解决问题。而且，还要注意细节，可以将
log4 当做常量抽取出来，这样不用每次都重复计算，果然是学霸范儿。

不过呢，利用 Math.log
方法也算是某种意义上的犯规吧，有没有不用数学函数，用原生方法来解决呢？

当然有了！而且还不止一种，大家可以继续想30秒，要至少想出一种哦 ——

统计“1”的个数

给定一个非负整数 num，对于任意 i，0 ≤ i ≤ num，计算 i
的值对应的二进制数中 “1” 的个数，将这些结果返回为一个数组。

例如：

当 num = 5 时，返回值为 [0,1,1,2,1,2]。

/** * @param {number} num * @return {number[]} */ var countBits =
function(num) { //在此处实现代码 };

1
2
3
4
5
6
7
/**
* @param {number} num
* @return {number[]}
*/
var countBits = function(num) {
    //在此处实现代码
};

一个满足题目要求的输入范例。

　　现在来讲max的作用，用来把数变小的，我们可以想象如果是很大的数的很高次方，乘几次后数据非常大无法用任何一个基本数据类型表示，而且这也是不必要的，通常我们只需要知道最后若干位的值，这就可以用到取余了，余数的幂和原数的幂在余数的位数上是相同的，所以每次进行乘法运算后都要取余，当然如果数据很小也可以不用取余。

打赏支持我写出更多好文章，谢谢！

任选一种支付方式

图片 1
图片 2

1 赞 7 收藏 2
评论

打赏支持我写出更多好文章，谢谢！

任选一种支付方式

图片 3
图片 4

3 赞 8 收藏 5
评论

④输出位数。

11 = 2³×1 + 2²×0 + 2¹×1 + 2º×1

不用内置函数

这个问题的关键思路和上一道题类似，先考虑“4”的幂的二进制表示：

  • 40 = 1B
  • 41 = 100B
  • 42 = 10000B
  • 43 = 1000000B
  • ……

也就是每个数比上一个数的二进制后面多两个零嘛。最重要的是，“4”的幂的二进制数只有
1 个“1”。如果仔细阅读过上一篇，你就会知道，判断一个二进制数只有 1
个“1”，只需要：

JavaScript

(num & num – 1) === 0

1
(num & num – 1) === 0

但是，二进制数只有 1
个“1”只是“4”的幂的必要非充分条件，因为“2”的奇数次幂也只有 1
个“1”。所以，我们还需要附加的判断：

JavaScript

(num & num – 1) === 0 && (num & 0xAAAAAAAA) === 0

1
(num & num – 1) === 0 && (num & 0xAAAAAAAA) === 0

为什么是 num & 0xAAAAAAAA === 0? 因为这个确保 num 的二进制的那个 “1”
出现在“奇数位”上，也就确保了这个数确实是“4”的幂，而不仅仅只是“2”的幂。

最后，我们得到完整的版本：

版本3

JavaScript

function isPowerOfFour(num) { return num > 0 && (num & (num-1)) === 0
&& (num & 0xAAAAAAAA) === 0; };

1
2
3
4
function isPowerOfFour(num) {
    return num > 0 && (num & (num-1)) === 0
                   && (num & 0xAAAAAAAA) === 0;
};

上面的代码需要加上 num > 0，是因为 0 要排除在外，否则 (0 & -1) === 0
也是 true

countBits 的时间复杂度

考虑 countBits， 上面的算法：

  • “版本1” 的时间复杂度是 O(N*M)，M 取决于 Number.prototype.toString
    和 String.prototype.replace 的复杂度。
  • “版本2” 的时间复杂度是 O(N*logN)
  • “版本3” 的时间复杂度是 O(N*M)，M 是 N 的二进制数中的“1”的个数，介于
    1 ~ logN 之间。

上面三个版本的 countBits 的时间复杂度都大于 O(N)。那么有没有时间复杂度
O(N) 的算法呢？

实际上，“版本3”已经为我们提示了答案，答案就在上面的那个定律里，我把那个等式再写一遍：

countBit(n & (n – 1)) === countBit(n) – 1

1
countBit(n & (n – 1)) === countBit(n) – 1

也就是说，如果我们知道了 countBit(n & (n - 1))，那么我们也就知道了
countBit(n)！

而我们知道 countBit(0) 的值是 0，于是，我们可以很简单的递推：

版本4

function countBits(nums){ var ret = [0]; for(var i = 1; i <= nums;
i++){ ret.push(ret[i & i – 1] + 1); } return ret; }

1
2
3
4
5
6
7
function countBits(nums){
   var ret = [0];
   for(var i = 1; i <= nums; i++){
       ret.push(ret[i & i – 1] + 1);
   }
   return ret;
}

原来就这么简单，你想到了吗 ╮(╯▽╰)╭

以上就是所有的内容，简单的题目思考起来很有意思吧？程序员就应该追求完美的算法，不是吗？

这是 leetcode
算法面试题系列的第一期，下一期我们讨论另外一道题，这道题也很有趣：判断一个非负整数是否是
4 的整数次方，别告诉我你用循环，想想更巧妙的办法吧~

打赏支持我写出更多好文章，谢谢！

打赏作者

  int n; 

 1 #include<iostream>
 2 using namespace std;
 3 
 4 int cal(int x, int n, int max){
 5     int sum = 1;
 6     while (n > 0){
 7         if (n & 1)
 8             sum = sum*x%max;
 9         n >>= 1;
10         x = x*x%max;
11     }
12     return sum;
13 }
14 int main(){
15     int x, n;
16     while ((cin >> x >> n) && (x || n)){
17         cout << cal(x, n, 1000) << endl;
18     }
19     return 0;
20 }

关于作者：十年踪迹

图片 5

月影，奇舞团团长，热爱前端开发，JavaScript
程序猿一枚，能写代码也能打杂卖萌说段子。
个人主页 ·
我的文章 ·
14 ·
    

图片 6

更快的 countBit

上一个版本的 countBit 的时间复杂度已经是 O(logN)
了，难道还可以更快吗？当然是可以的，我们不需要去判断每一位是不是“1”，也能知道
n 的二进制中有几个“1”。

有一个诀窍，是基于以下一个定律：

  • 对于任意 n， n ≥ 1，有如下等式成立：

countBit(n & (n – 1)) === countBit(n) – 1

1
countBit(n & (n – 1)) === countBit(n) – 1

这个很容易理解，大家只要想一下，对于任意 n，n – 1 的二进制数表示正好是 n
的二进制数的最末一个“1”退位，因此 n & n – 1 正好将 n
的最末一位“1”消去，例如：

  • 6 的二进制数是 110， 5 = 6 – 1 的二进制数是 101，6 & 5
    的二进制数是 110 & 101 == 100
  • 88 的二进制数是 1011000，87 = 88 – 1 的二进制数是
    1010111，88 & 87 的二进制数是 1011000 & 1010111 == 1010000

于是，我们有了一个更快的算法：

版本3

function countBit(n){ var ret = 0; while(n > 0){ ret++; n &= n – 1; }
return ret; } function countBits(nums){ var ret = []; for(var i = 0; i
<= nums; i++){ ret.push(countBit(i)); } return ret; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function countBit(n){
    var ret = 0;
    while(n > 0){
        ret++;
        n &= n – 1;
    }
    return ret;
}
 
function countBits(nums){
   var ret = [];
   for(var i = 0; i <= nums; i++){
       ret.push(countBit(i));
   }
   return ret;
}

上面的 countBit(88) 只循环 3 次，而“版本2”的 countBit(88) 却需要循环
7 次。

优化到了这个程度，是不是一切都结束了呢？从算法上来说似乎已经是极致了？真的吗？再给大家
30 秒时间思考一下，然后再往下看。

{

 

解题思路

如果忽略“附加条件”，这题还挺简单的对吧？简直是信手拈来：

版本1

JavaScript

function isPowerOfFour(num){ while(!(num % 4)){ num /= 4; } return num
=== 1; }

1
2
3
4
5
6
function isPowerOfFour(num){
    while(!(num % 4)){
        num /= 4;
    }
    return num === 1;
}

版本1 好像很简单、很强大的样子，它的时间复杂度是
log4N。有同学说，还可以做一些微小的改动：

版本1.1

JavaScript

function isPowerOfFour(num){ while(!(num % 4)){ num >>>= 2; }
return num === 1; }

1
2
3
4
5
6
function isPowerOfFour(num){
    while(!(num % 4)){
      num >>>= 2;
    }
    return num === 1;
}

上面的代码用位移替代除法，在其他语言中更快，鉴于 JS
通常情况下非常坑的位运算操作，不一定速度能变快。

好了，最关键的是，不管是 版本1 还是 版本1.1
似乎都不满足我们前面提到的“附加条件”，即不使用循环和递归，或者说，我们需要寻找
O(1) 的解法。

按照惯例，大家先思考10秒钟，然后往下看 ——

关于作者：十年踪迹

图片 7

月影，奇舞团团长，热爱前端开发，JavaScript
程序猿一枚，能写代码也能打杂卖萌说段子。
个人主页 ·
我的文章 ·
14 ·
    

图片 6

9

int cal(int x, int n, int max){

其他版本

上面的版本已经符合了我们的需求，时间复杂度是 O(1)，不用循环和递归。

此外，我们还可以有其他的版本，它们严格来说有的还是“犯规”，但是我们还是可以学习一下这些思路：

版本4：用 Math.sqrt

JavaScript

function isPowerOfFour(num) { num = Math.sqrt(num); return num > 0 &&
num === (0|num) && (num & (num-1)) === 0; };

1
2
3
4
function isPowerOfFour(num) {
    num = Math.sqrt(num);
    return num > 0 && num === (0|num) && (num & (num-1)) === 0;
};

版本5：用正则表达式

JavaScript

function isPowerOfFour(num) { return /^1(00)*$/g.test(num.toString(2));
};

1
2
3
function isPowerOfFour(num) {
    return /^1(00)*$/g.test(num.toString(2));
};

以上就是所有的内容，这道题有非常多种思路，相当有趣，也比较考验基本功。如果你有自己的思路，可以留言参与讨论。

下一期我们讨论另外一道题，这道题比这两道题要难一些，但也更有趣：给定一个正整数
n，将它拆成至少两个正整数之和，对拆出的正整数求乘积，返回能够得到的乘积最大的结果。

想一想你的解法是什么？你能够尽可能减少算法的时间复杂度吗？期待你的答案~~

打赏支持我写出更多好文章，谢谢！

打赏作者

别人家的面试题：统计“1”的个数

2016/05/27 · JavaScript
· 5 评论 ·
Javascript,
算法

本文作者： 伯乐在线 –
十年踪迹
。未经作者许可，禁止转载！
欢迎加入伯乐在线 专栏作者。

小胡子哥 @Barret李靖
给我推荐了一个写算法刷题的地方
leetcode.com，没有 ACM
那么难，但题目很有趣。而且据说这些题目都来源于一些公司的面试题。好吧，解解别人公司的面试题其实很好玩，既能整理思路锻炼能力，又不用担心漏题
╮(╯▽╰)╭。

长话短说，让我们来看一道题：

    {

　　　　sum =
sum*x%max;//如果为1，sum就要乘x^i,i为该位在二进制数中的位置
　　n >>=
1;　　　　　　//>>为位运算符，右移一位，即去掉已经计算过的部分
　　x =
x*x%max;　　　　//用来标记记录x^2^i,循环i次即去掉了i位,当第i+1位为1时，sum就要乘x^2^i;
　　}
　　return sum;//循环结束返回结果。
}

别人家的面试题：一个整数是否是“4”的N次幂

2016/05/30 · 基础技术 ·
2 评论 ·
算法

本文作者： 伯乐在线 –
十年踪迹
。未经作者许可，禁止转载！
欢迎加入伯乐在线 专栏作者。

这是 leetcode.com
的第二篇。与上一篇一样，我们讨论一道相对简单的问题，因为学习总讲究循序渐进。而且，就算是简单的问题，追求算法的极致的话，其中也是有大学问的。

解题思路

这道题咋一看还挺简单的，无非是：

  • 实现一个方法 countBit，对任意非负整数
    n，计算它的二进制数中“1”的个数
  • 循环 i 从 0 到 num，求 countBit(i)，将值放在数组中返回。

JavaScript中，计算 countBit 可以取巧：

function countBit(n){ return n.toString(2).replace(/0/g,””).length; }

1
2
3
function countBit(n){
    return n.toString(2).replace(/0/g,"").length;
}

上面的代码里，我们直接对 n 用 toString(2)
转成二进制表示的字符串，然后去掉其中的0，剩下的就是“1”的个数。

然后，我们写一下完整的程序：

版本1

function countBit(n){ return n.toString(2).replace(/0/g,”).length; }
function countBits(nums){ var ret = []; for(var i = 0; i <= nums;
i++){ ret.push(countBit(i)); } return ret; }

1
2
3
4
5
6
7
8
9
10
11
function countBit(n){
   return n.toString(2).replace(/0/g,”).length;
}
 
function countBits(nums){
   var ret = [];
   for(var i = 0; i <= nums; i++){
       ret.push(countBit(i));
   }
   return ret;
}

上面这种写法十分讨巧，好处是 countBit 利用 JavaScript
语言特性实现得十分简洁，坏处是如果将来要将它改写成其他语言的版本，就有可能懵B了，它不是很通用，而且它的性能还取决于
Number.prototype.toString(2) 和 String.prototype.replace 的实现。

所以为了追求更好的写法，我们有必要考虑一下 countBit 的通用实现法。

我们说，求一个整数的二进制表示中 “1” 的个数，最普通的当然是一个 O(logN)
的方法：

function countBit(n){ var ret = 0; while(n > 0){ ret += n & 1; n
>>= 1; } return ret; }

1
2
3
4
5
6
7
8
function countBit(n){
    var ret = 0;
    while(n > 0){
        ret += n & 1;
        n >>= 1;
    }
    return ret;
}

所以我们有了版本2

这么实现也很简洁不是吗？但是这么实现是否最优？建议此处思考10秒钟再往下看。

    b=fun(num1);

即把n化为2进制数，每个为1的位都是较小的一部分。这样可以用一个循环来解决。下面是快速幂的非递归代码，暂时忽略max

“4”的整数次幂

给定一个32位有符号整数（32 bit signed
integer），写一个函数，检查这个整数是否是“4”的N次幂，这里的N是非负整数。

例如：

  • 给定 num = 16，返回 true，因为 16 = 42
  • 给定 num = 5，返回 flase

附加条件： 你能够不用循环和递归吗？

　　输入数据中每一个数的范围。

　　int sum = 1;　　　　//最后输出的结果
　　while (n > 0){　　　//当幂降为0是结束
　　if (n &
1)　　　　　　//位运算，&是按位与，当两边都为1，表达式为1，这个是用来判断二进制数最后一位是否为1，这里n是以二进制的形式比较的

　　两个整数都小于10000

　　第一总比较土鳖，每次乘完对1000取余也可以过。

①定义变量：两个整数；

　　简单的说这题就是要求高次幂，有两种方法可以实现。

提交此题   

求A^B的最后三位数表示的整数。
说明：A^B的含义是“A的B次方”

    }

Problem Description

与上面的样例输入对应的输出。

下面贴上上面那题的代码

printf(“%d\n”,s);

对于每个测试实例，请输出A^B的最后三位表示的整数，每个输出占一行。

时间限制：1.0s  内存限制：256.0MB

11的二进制是1011

  printf(“\n”);

 Input

时间限制：10.0s  内存限制：256.0MB

　　好了，感觉我已经讲的很详细了！！真的是尽力了。。。

    }

　　我要讲的是第二种听起来很高大上的方法——快速幂。为什么叫快速幂呢？因为用它求幂非常快，对于x^n,复杂度为O（logn），是不是很吊！快速幂的原理是把幂分解，把一个很大的幂分解成较小的几部分。例如：

问题描述

输入数据包含多个测试实例，每个实例占一行，由两个正整数A和B组成（1<=A,B<=10000），如果A=0,
B=0，则表示输入数据的结束，不做处理。

#include “stdio.h”

 Output

int main()

因此，我们将a¹¹转化为 图片 9

{

（2）for语句循环（从1开始，循环到该数），用if语句判断该数是否被约数整除余数为0，如果为0，则累加；

数据规模和约定

②输入十进制整数；

        if(n % i==0){

    while(n!=0)

4

    return 0;

时间限制：1.0s  内存限制：512.0MB

③调用函数：

样例输入

Author

发表评论

电子邮件地址不会被公开。 必填项已用*标注