Question

我有两种解决此问题的算法：Generate all sequences of bits within Hamming distance t。现在我想在理论上比较它们（如果需要，我确实有时间测量）。

O（（n选择t）* n）

其中n是位串的长度，t是所需的汉明距离。

recursive algorithm，我们迄今为止最好的是：

O（2 ^ n）的

但如何比较这两个时间复杂度，而不在第二时间复杂度中引入t？出于这个原因，我试图这样做，你能帮忙吗？

递归算法：

// str is the bitstring, i the current length, and changesLeft the
// desired Hamming distance (see linked question for more)
void magic(char* str, int i, int changesLeft) {
        if (changesLeft == 0) {
                // assume that this is constant
                printf("%s\n", str);
                return;
        }
        if (i < 0) return;
        // flip current bit
        str[i] = str[i] == '0' ? '1' : '0';
        magic(str, i-1, changesLeft-1);
        // or don't flip it (flip it again to undo)
        str[i] = str[i] == '0' ? '1' : '0';
        magic(str, i-1, changesLeft);
}

Answer 1

在最常见的时间复杂度水平上，我们有一个 t = n / 2 的“最坏情况”。现在，修复 t 并逐渐增加 n 。我们从n = 8，t = 4

开始

C(8 4) = 8*7*6*5*4*3*2*1 / (4*3*2*1 * 4*3*2*1)
    = 8*7*6*5 / 24
n <= n+1 ... n choose t is now

C(9 4) = ...
    = 9*8*7*6 / 24
    = 9/5 of the previous value.

现在，进展更容易观察。

C( 8 4) = 8*7*6*5 / 24
C( 9 4) =  9/5 * C( 8 4)
C(10 4) = 10/6 * C( 9 4)
C(11 4) = 11/7 * C(10 4)
...
C( n 4) = n/(n-4) * C(n-1 4)

现在，作为学生的引理：

找出基本复杂度，n！ /（（n-1）！^ 2）
找出常数c

Answer 2

递归算法也是O((n choose t) * n)，通过分析向每个打印组合收取打印时整个调用堆栈的成本。我们可以这样做，因为magic的每次调用（两个O(1)叶子调用除了我们可以轻易取消的i < 0之外）都会打印出来。

如果您为打印指定其真实成本，则最好能够进行此限制。否则，我很确定两个分析都可以收紧O(n choose t)，不包括t > 0的打印，详细信息请参见Knuth 4A。

试图比较递归和迭代算法

2 个答案: