Algorithm 带因变量的嵌套循环

假设我们有以下循环：

for (int i = 0; i < n; i++)
   for (int j = i+1; j < n; j++)
      for (int k = j+1; k < n; k++)
         for (int l = 0; l < n; l++)

for（int i=0；i

我知道第一个循环将循环n次

我认为第二个将运行（1/2）*（n^2+n-2）次，因为我们需要计算从2到n的和，而不是从1到n的和

但是，我不知道第三个和第四个。

理解时间复杂性有（至少）两种方法：第一种方法是注意到三个嵌套的for循环精确地生成

n

-集的所有

3

-子集，第二种方法是“直接”方法

组合论元 前三个for循环精确地选择

n

-集合的所有

3

-子集，每个

3

-子集精确地选择一次（仔细想想）。有

（n选择3）=O（n^3）

这样的子集（参见）。最里面的循环对其他三个循环的

O（n）

每一个

O（n^3）

迭代都有效，因此总时间是

O（n^4）

这三个循环（没有最里面的一个）完全是

n选择3=n/（3！（n-3）！

迭代。这正是

n*（n-1）*（n-2）/6次迭代

直接论点
最里面的循环将执行
n
次，而不考虑其他循环，因此时间复杂度将为
O（n*f（n））
，其中
f（n）
是如果移除最里面的循环，则其他三个循环的时间复杂度

两个最里面的循环（索引为
j
-和
k
-的循环）一起占用
O（i^2）
时间。这是很容易看到的——它与从
j=0
到
i-1
和
k=j
到
i-1
的双循环相同，因此时间是
O（1）+O（2）+…+O（i）=O（i^2）

因为outtermost循环从
i=0
到
n-1
，所以总的复杂度是
n*（O（1^2）+O（2^2）+…+O（n^2））
，也就是
O（n*n^3）
：outtermost循环（
i
-索引）执行double for循环（
j
-和
k
-索引）从
i=0
到
i=n-1

因此，我们有
O（n^4）
总运行时间

要获得精确的迭代次数，您必须为合适的
i
计算一个项的总和
i*（i-1）/2=（i^2-i）/2
。让我们只计算和，最后除以2

你可以把它分成两个和

(1^2 + 2^2 + ...n-1) - (1 + 2 + ... + n-1) =
= n(n-1)(2n-1)/6 - n*(n-1)/2 =
= n*(n-1)(n-2)/3

现在我们除以2，得到结果
n*（n-1）*（n-2）/6
。同上。（请参阅。）
理解时间复杂性有（至少）两种方法：第一种方法是注意三个嵌套的for循环精确地生成
n
-集的所有
3
-子集，第二种方法是“直接”方法

组合论元
前三个for循环精确地选择
n
-集合的所有
3
-子集，每个
3
-子集精确地选择一次（仔细想想）。有
（n选择3）=O（n^3）
这样的子集（参见）。最里面的循环对其他三个循环的
O（n）
每一个
O（n^3）
迭代都有效，因此总时间是
O（n^4）

这三个循环（没有最里面的一个）完全是
n选择3=n/（3！（n-3）！
迭代。这正是
n*（n-1）*（n-2）/6次迭代

直接论点
最里面的循环将执行
n
次，而不考虑其他循环，因此时间复杂度将为
O（n*f（n））
，其中
f（n）
是如果移除最里面的循环，则其他三个循环的时间复杂度

两个最里面的循环（索引为
j
-和
k
-的循环）一起占用
O（i^2）
时间。这是很容易看到的——它与从
j=0
到
i-1
和
k=j
到
i-1
的双循环相同，因此时间是
O（1）+O（2）+…+O（i）=O（i^2）

因为outtermost循环从
i=0
到
n-1
，所以总的复杂度是
n*（O（1^2）+O（2^2）+…+O（n^2））
，也就是
O（n*n^3）
：outtermost循环（
i
-索引）执行double for循环（
j
-和
k
-索引）从
i=0
到
i=n-1

因此，我们有
O（n^4）
总运行时间

要获得精确的迭代次数，您必须为合适的
i
计算一个项的总和
i*（i-1）/2=（i^2-i）/2
。让我们只计算和，最后除以2

你可以把它分成两个和

(1^2 + 2^2 + ...n-1) - (1 + 2 + ... + n-1) =
= n(n-1)(2n-1)/6 - n*(n-1)/2 =
= n*(n-1)(n-2)/3

现在我们除以2，得到结果
n*（n-1）*（n-2）/6
。同上。（请参阅。）
第一个循环将重复n次，第二个循环将进行（n-1）次，第三个循环将进行（n-2）次，最后一个循环将进行l次。到最后，他们都会去的
n*（n-1）*（n-2）*l
次数。
第一个循环将重复n次，第二个循环将进行（n-1）次，第三个循环将进行（n-2）次，最后一个循环将进行l次。到最后，他们都会去的
n*（n-1）*（n-2）*l
时间。
好的，我了解运行时间复杂性，但是嵌套循环的确切迭代次数是多少？确切地说是
n选择3
。这是
n！/（3！*（n-3）！
，或者简化为
n*（n-1）*（n-2）/6
。好的，我理解运行时复杂性，但是嵌套循环的确切迭代次数是多少？确切地说是
n选择3
。这是
n！/（3！*（n-3）！
，或者简化为
n*（n-1）*（n-2）/6
。