C++ 迭代算法的时间复杂度

我试图找出这个问题的时间复杂性

---

迭代：算法从输入位字符串生成给定汉明距离内的所有位字符串。它生成所有递增序列

0注意，给定
n
表示长度，和
t
表示所需距离，
1
和
n
（或者在索引形式中，介于
0
和
n-1
之间）确实是
n选择t
，因为我们选择了
t
不同的索引

问题发生在您这一代的这些系列中：

-首先，请注意，例如，在长度为4的情况下，您实际使用了5个不同的索引，从0到4

-其次，请注意，您考虑的是具有相同指数的序列（在
t=2
的情况下，其
0、1、2
等），通常，您会经历每一个非递减序列，而不是每一个递增序列

因此，在计算程序的TC时，请确保将其考虑在内

提示：试着从这些系列的宇宙到一些方程的整数解的宇宙进行一对一的对应

如果您需要直接解决方案，请查看以下内容：


最后的解决方案是
（n+t-1）选择（t）
，但是注意到第一个项目符号，在您的程序中，它实际上是
（（n+1）+t-1）选择（t）
，因为您使用一个额外的索引循环。
表示

（（n+1）+t-1）选择（t）=:A
，
n选择t=:B

总的来说，我们得到了
O（1）+B*O（n）+（A-B）*O（1）
while循环有点聪明和微妙，可以说它在做两件不同的事情（如果你把
A
的初始化计算在内，甚至是三件事）。这正是使复杂度计算变得具有挑战性的原因，而且它的效率也比它可能的低

在摘要中，要从当前索引增量计算下一组索引，其思想是找到最后一个小于
n-dist+i
的索引
i
，将其增量，并将以下索引设置为
a[i]+1
，
a[i]+2
，依此类推

例如，如果dist=5，n=11，您的索引为：

0, 3, 5, 9, 10

然后
5
是小于
n-dist+i
的最后一个值（因为
n-dist
是6，10=6+4，9=6+3，但5=0；i--）{
如果（a[i]对于（int j=i+1；j+1.Re:“N_INCR_SEQ（N，dist）是自然数的递增序列的数量<长度dist的N”：正如OP已经认识到的，该数字是（N dist）。顺便说一句，您分析的一个含义是OP可以通过更改
if（++a[k]>=N的行来最小程度地修复他/她的代码的性能）
to
if（++a[k]>n-dist+k）
。这将消除所有不必要的/非生产性的来回传递。确实是@ruakh，但我更喜欢保罗的代码，在我年轻的眼睛看来，它似乎更优雅！因此总体时间复杂度为O（（n选择dist）*n）。@gsamaras：是的，我也更喜欢保罗的代码。（哦，除了
int a之外。）[DIST] < /C> >不是有效的C++；C有可变长度数组，所以一些编译器支持C++中的编译器扩展，但它们不是C++标准的一部分。所以我认为使用“<代码> STD:：vector < /COD>”是正确的。）@ AlxD<代码> Hamming（“40”）
显示了优化的重要性。我的代码版本实际上与你的代码做了同样多的工作（假设ruakh在第二条注释中做了上述更改，以消除过度的磨损）。我的每次迭代做更多的工作，但你的可以在打印语句之间进行多次迭代。两个版本的代码完全平衡，因为它们做的基本相同。我认为你的“第二”段不正确。请注意，
while
-循环以无条件递增
a[k]
开始。（由于某种原因，它被塞进了
if
-test中，但它就在那里。）@ruakh查看他的运行示例，我认为它确实经过了每个非递减序列。我错了吗？他/她的运行示例在每个循环迭代开始时显示了向量的内容；但是向量在循环迭代期间被修改。但是，它很复杂。向量的内容永远不会像
1
（相同的值重复三次），但它们可以暂时类似于
14
或
12
。因此，总的来说，您也同意我的算法比Paul提供的算法慢，谢谢，+1。
len = 3, (3 choose 2) = 3 * O(n), 10 while iterations
len = 4, (4 choose 2) = 6 * O(n), 15 while iterations
len = 5, (5 choose 2) = 9 * O(n), 21 while iterations
len = 6, (6 choose 2) = 15 * O(n), 28 while iterations

000, len = 3
k = 0, total_iter = 1
vector a = -1 0 
k = 1, total_iter = 2
vector a = 0 0 
Paid O(n)
k = 1, total_iter = 3
vector a = 0 1 
Paid O(n)
k = 1, total_iter = 4
vector a = 0 2 
k = 0, total_iter = 5
vector a = 0 3 
k = 1, total_iter = 6
vector a = 1 1 
Paid O(n)
k = 1, total_iter = 7
vector a = 1 2 
k = 0, total_iter = 8
vector a = 1 3 
k = 1, total_iter = 9
vector a = 2 2 
k = 0, total_iter = 10
vector a = 2 3 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gsamaras@pythagoras:~/Desktop/generate_bitStrings_HammDistanceT$ ./iter
0000, len = 4
k = 0, total_iter = 1
vector a = -1 0 
k = 1, total_iter = 2
vector a = 0 0 
Paid O(n)
k = 1, total_iter = 3
vector a = 0 1 
Paid O(n)
k = 1, total_iter = 4
vector a = 0 2 
Paid O(n)
k = 1, total_iter = 5
vector a = 0 3 
k = 0, total_iter = 6
vector a = 0 4 
k = 1, total_iter = 7
vector a = 1 1 
Paid O(n)
k = 1, total_iter = 8
vector a = 1 2 
Paid O(n)
k = 1, total_iter = 9
vector a = 1 3 
k = 0, total_iter = 10
vector a = 1 4 
k = 1, total_iter = 11
vector a = 2 2 
Paid O(n)
k = 1, total_iter = 12
vector a = 2 3 
k = 0, total_iter = 13
vector a = 2 4 
k = 1, total_iter = 14
vector a = 3 3 
k = 0, total_iter = 15
vector a = 3 4 

0, 3, 5, 9, 10

0, 3, 6, 7, 8

0, 3, 5, 9, 10

void hamming2(const char* num, size_t dist) {
    int a[dist];
    for (int i = 0; i < dist; i++) {
        a[i] = i;
    }
    size_t n = strlen(num);
    while (true) {
        print(num, a);
        int i;
        for (i = dist - 1; i >= 0; i--) {
            if (a[i] < n - dist + i) break;
        }
        if (i < 0) return;
        a[i]++;
        for (int j = i+1; j<dist; j++) a[j] = a[i] + j - i;
    }
}