Question

给定位v的向量，计算汉明距离为1的位集合v，然后距离为2，直到输入参数{{ 1}}。

所以

如何有效地计算？矢量不总是尺寸为3，例如它可能是6.这将在我的实际代码中运行很多时间，因此一些效率也会受到欢迎（即使支付更多内存）。

我的尝试：

011  I should get
~~~ 
111
001
010
~~~ -> 3 choose 1 in number
101
000
110
~~~ -> 3 choose 2
100
~~~ -> 3 choose 3

输出：

#include <iostream>
#include <vector>

void print(const std::vector<char>& v, const int idx, const char new_bit)
{
    for(size_t i = 0; i < v.size(); ++i)
        if(i != idx)
            std::cout << (int)v[i] << " ";
        else
            std::cout << (int)new_bit << " ";
    std::cout << std::endl;
}

void find_near_hamming_dist(const std::vector<char>& v, const int t)
{
    // if t == 1
    for(size_t i = 0; i < v.size(); ++i)
    {
        print(v, i, v[i] ^ 1);
    }

    // I would like to produce t == 2
    // only after ALL the t == 1 results are reported
    /* how to? */
}

int main()
{
    std::vector<char> v = {0, 1, 1};
    find_near_hamming_dist(v, 1);
    return 0; 
}

Answer 1

首先：汉明k k位向量与k（分别为v.size() n的子集）（具有改变位的索引集）之间存在双射。因此，我将枚举更改的索引的子集。快速浏览SO历史记录显示this参考。当然，你必须跟踪正确的红衣主教。

考虑到效率可能毫无意义，因为无论如何，问题的解决方案都是指数级的。

Answer 2

如果汉明距离h(u, v) = k，则u^v设置了k位。换句话说，在设置了u ^ m位的所有掩码m上计算k会给出具有所需汉明距离的所有单词。请注意，这样的掩码集不依赖于u。

也就是说，n和t相当小的预先计算的掩码集，k位设置为k，1,t，并迭代根据需要在这些集合上。

如果你没有足够的内存，你可以动态生成k位模式。有关详细信息，请参阅this discussion。

Answer 3

#include <stdio.h>
#include <stdint.h>
#include <string.h>

void magic(char* str, int i, int changesLeft) {
        if (changesLeft == 0) {
                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);
}

int main(void) {
        char str[] = "011";
        printf("%s\n", str);
        size_t len = strlen(str);
        size_t maxDistance = len;
        for (size_t i = 1 ; i <= maxDistance ; ++i) {
                printf("Computing for distance %d\n", i);
                magic(str, len-1, i);
                printf("----------------\n");
        }
        return 0;
}

输出：

MacBook-Pro:hammingDist gsamaras$ nano kastrinis.cpp
MacBook-Pro:hammingDist gsamaras$ g++ -Wall kastrinis.cpp 
MacBook-Pro:hammingDist gsamaras$ ./a.out 
011
Computing for distance 1
010
001
111
----------------
Computing for distance 2
000
110
101
----------------
Computing for distance 3
100
----------------

Answer 4

回应Kastrinis＆＃39;回答，我想验证这可以扩展到我的基础示例，如下：

#include <iostream>
#include <vector>

void print(std::vector<char>&v)
{
    for (auto i = v.begin(); i != v.end(); ++i)
        std::cout << (int)*i;
    std::cout << "\n";
}

void magic(std::vector<char>& str, const int i, const int changesLeft) {
        if (changesLeft == 0) {
                print(str);
                return;
        }
        if (i < 0) return;
        // flip current bit
        str[i] ^= 1;
        magic(str, i-1, changesLeft-1);
        // or don't flip it (flip it again to undo)
        str[i] ^= 1;
        magic(str, i-1, changesLeft);
}

int main(void) {
        std::vector<char> str = {0, 1, 1};
        print(str);
        size_t len = str.size();
        size_t maxDistance = str.size();
        for (size_t i = 1 ; i <= maxDistance ; ++i) {
                printf("Computing for distance %lu\n", i);
                magic(str, len-1, i);
                printf("----------------\n");
        }
        return 0;
}

输出相同。

_{PS - 我也是toggling the bit with a different way。}

生成汉明距离t内的所有比特序列

4 个答案: