这段代码没有优化的是什么?

时间:2012-11-11 13:52:52

标签: c++ optimization

我在面试街上写了一个问题的解决方案,这里是问题描述:

https://www.interviewstreet.com/challenges/dashboard/#problem/4e91289c38bfd

以下是他们给出的解决方案:

https://gist.github.com/1285119

以下是我编码的解决方案:

#include<iostream>
#include <string.h>
using namespace std;
#define LOOKUPTABLESIZE 10000000
int popCount[2*LOOKUPTABLESIZE];
int main()
{
int numberOfTests = 0;
cin >> numberOfTests;

for(int test = 0;test<numberOfTests;test++)
{
    int startingNumber = 0;
    int endingNumber = 0;
    cin >> startingNumber >> endingNumber;

    int numberOf1s = 0;


    for(int number=startingNumber;number<=endingNumber;number++)
    {
        if(number >-LOOKUPTABLESIZE && number < LOOKUPTABLESIZE)
        {
            if(popCount[number+LOOKUPTABLESIZE] != 0)
            {
                numberOf1s += popCount[number+LOOKUPTABLESIZE];
            }
            else
            {
                popCount[number+LOOKUPTABLESIZE] =__builtin_popcount (number);
                numberOf1s += popCount[number+LOOKUPTABLESIZE];
            }
        }
        else
        {
        numberOf1s += __builtin_popcount (number);
        }
    }
    cout << numberOf1s << endl;

}

}

你能指出我的代码有什么问题吗?它只能通过3/10的测试。时间限制是3秒。

2 个答案:

答案 0 :(得分:5)

  

这段代码未被优化的内容是什么?

算法。你正在循环

for(int number=startingNumber;number<=endingNumber;number++)

计算或查找每个中的1位数。这可能需要一段时间。

一个好的算法使用一些数学计算0 <= k < n时间内所有数字O(log n)中的1位数。

Here是一个在十进制扩展中计算0的实现,使其计数为1位的修改应该不难。

答案 1 :(得分:1)

在查看这样的问题时,您需要将其分解为简单的部分。

例如,假设您知道所有数字[0, N]中有多少1(我们称之为ones(N)),那么我们就有:

size_t ones(size_t N) { /* magic ! */ }

size_t count(size_t A, size_t B) {
    return ones(B) - (A ? ones(A - 1) : 0);
}

这种方法的优点是one编程count可能更简单,例如使用递归。因此,第一次天真的尝试将是:

// Naive
size_t naive_ones(size_t N) {
    if (N == 0) { return 0; }
    return __builtin_popcount(N) + naive_ones(N-1);
}

但这可能太慢了。即使只是简单地计算count(B, A)的值,我们也会计算naive_ones(A-1)两次!

幸运的是,总会有备忘录在这里提供帮助,而且转变非常简单:

size_t memo_ones(size_t N) {
    static std::deque<size_t> Memo(1, 0);
    for (size_t i = Memo.size(); i <= N; ++i) {
        Memo.push_back(Memo[i-1] + __builtin_popcnt(i));
    }
    return Memo[N];
}

这可能会有所帮助,但是内存方面的成本可能会......瘫痪。啊。想象一下,对于计算ones(1,000,000),我们将在64位计算机上占用8MB内存!较稀疏的备忘录可能有所帮助(例如,只记忆每8或16次计数):

// count number of ones in (A, B]
static unoptimized_count(size_t A, size_t B) {
    size_t result = 0;
    for (size_t i = A + 1; i <= B; ++i) {
        result += __builtin_popcount(i);
    }
    return result;
}

// something like this... be wary it's not tested.
size_t memo16_ones(size_t N) {
    static std::vector<size_t> Memo(1, 0);
    size_t const n16 = N  - (N % 16);
    for (size_t i = Memo.size(); i*16 <= n16; ++i) {
        Memo.push_back(Memo[i-1] + unoptimized_count(16*(i-1), 16*i);
    }
    return Memo[n16/16] + unoptimized_count(n16, N);
}

然而,虽然它确实降低了内存成本,但它并没有解决主要速度问题:我们必须至少使用__builtin_popcount B次!对于较大的B值,这是一个杀手。


上述解决方案是机械,它们不需要一盎司的思考。事实证明,访谈不是关于编写代码而是关于思考。

我们能否更有效地解决这个问题,而不是简单地枚举所有整数直到B

在考虑前几个条目时,让我们看看我们的大脑(相当惊人的模式机器):

N    bin  1s   ones(N)
0    0000 0    0
1    0001 1    1
2    0010 1    2
3    0011 2    4
4    0100 1    5
5    0101 2    7
6    0110 2    9
7    0111 3    12
8    1000 1    13
9    1001 2    15
10   1010 2    17
11   1011 3    20
12   1100 2    22
13   1101 3    25
14   1110 3    28
15   1111 3    32

注意一个模式?我这样做;)8-15的范围与0-7完全相同,但是每行多一个=&gt;它就像一个转置。它也很合乎逻辑,不是吗?

因此,ones(15) - ones(7) = 8 + ones(7)ones(7) - ones(3) = 4 + ones(3)ones(1) - ones(0) = 1 + ones(0)

好吧,让我们把它作为一个公式:

  • 提醒:ones(N) = popcount(N) + ones(N-1)(差不多)按定义
  • 我们现在知道ones(2**n - 1) - ones(2**(n-1) - 1) = 2**(n-1) + ones(2**(n-1) - 1)

让我们制作孤立ones(2**n),更容易处理,请注意popcount(2**n) = 1

  • 重新组合:ones(2**n - 1) = 2**(n-1) + 2*ones(2**(n-1) - 1)
  • 使用定义:ones(2**n) - 1 = 2**(n-1) + 2*ones(2**(n-1)) - 2
  • 简化:ones(2**n) = 2**(n-1) - 1 + 2*ones(2**(n-1))ones(1) = 1

快速健全检查:

1  = 2**0 => 1  (bottom)
2  = 2**1 => 2  = 2**0 - 1 + 2 * ones(1)
4  = 2**2 => 5  = 2**1 - 1 + 2 * ones(2)
8  = 2**3 => 13 = 2**2 - 1 + 2 * ones(4)
16 = 2**4 => 33 = 2**3 - 1 + 2 * ones(8)

看起来很有效!


我们还没完成。 AB可能不一定是2的幂,如果我们必须从2**n2**n + 2**(n-1)一直计算,那仍然是O(N)!

另一方面,如果我们设法在基数2中表达数字,那么我们应该能够利用我们新获得的公式。主要优点是表示中只有log2(N)位。

让我们选择一个示例并了解其工作原理:13 = 8 + 4 + 1

1  -> 0001
4  -> 0100
8  -> 1000
13 -> 1101

...但是,计数不仅仅是总和:

ones(13) != ones(8) + ones(4) + ones(1)

让我们用“换位”策略来表达它:

ones(13) - ones(8) = ones(5) + (13 - 8)

ones(5) - ones(4) = ones(1) + (5 - 4)

好的,通过一些递归很容易。

#include <cmath>
#include <iostream>

static double const Log2 = log(2);

// store ones(2**n) at P2Count[n]
static size_t P2Count[64] = {};

// Unfortunately, the conversion to double might lose some precision
// static size_t log2(size_t n) { return log(double(n - 1))/Log2 + 1; }

// __builtin_clz* returns the number of leading 0s
static size_t log2(size_t n) {
    if (n == 0) { return 0; }
    return sizeof(n) - __builtin_clzl(n) - 1;
}

static size_t ones(size_t n) {
    if (n == 0) { return 0; }
    if (n == 1) { return 1; }

    size_t const lg2 = log2(n);
    size_t const np2 = 1ul << lg2; // "next" power of 2

    if (np2 == n) { return P2Count[lg2]; }

    size_t const pp2 = np2 / 2; // "previous" power of 2

    return ones(pp2) + ones(n - pp2) + (n - pp2);
} // ones

// reminder: ones(2**n) = 2**(n-1) - 1 + 2*ones(2**(n-1))
void initP2Count() {
    P2Count[0] = 1;

    for (size_t i = 1; i != 64; ++i) {
        P2Count[i] = (1ul << (i-1)) - 1 + 2 * P2Count[i-1];
    }
} // initP2Count

size_t count(size_t const A, size_t const B) {
    if (A == 0) { return ones(B); }

    return ones(B) - ones(A - 1);
} // count

demonstration

int main() {
    // Init table
    initP2Count();
    std::cout << "0: " << P2Count[0] << ", 1: " << P2Count[1] << ", 2: " << P2Count[2] << ", 3: " << P2Count[3] << "\n";

    for (size_t i = 0; i != 16; ++i) {
        std::cout << i << ": " << ones(i) << "\n";
    }

    std::cout << "count(7, 14): " << count(7, 14) << "\n";
}

胜利!

注意:正如丹尼尔费舍尔所指出的那样,这不能解释负数(但假设可以从正数计算出双补数)。