如果给出n 数字，我将如何找到可能的三角形的总数？有没有什么方法可以在O(n^3) 时间内做到这一点？
我正在考虑 a+b>c、b+c>a 和 a+c>b 成为三角形的条件。
【问题讨论】：
(a,b) (b≥a) 找到所有满足 b≤c≤a+b 的 cs。
标签： c complexity-theory
假设给定的 n 中没有相等的数字，并且允许多次使用一个数字。例如，我们给出了一个数字 {1,2,3}，所以我们可以创建 7 个三角形：
如果这些假设中的任何一个不正确，那么修改算法很容易。
这里我提出在最坏情况下需要 O(n^2) 时间的算法：
考虑两对 (i, j1) 和 (i, j2) j1 = k1（在 (i, j1) 的第 2 步中找到）。这意味着如果你对 j 进行迭代，你只需要检查从前一个 k 开始的数字。因此它为每个特定 i 提供了 O(n) 时间复杂度，这意味着整个算法的时间复杂度 O(n^2)。
C++源代码：
int Solve(int* a, int n)
{
int answer = 0;
std::sort(a, a + n);
for (int i = 0; i < n; ++i)
{
int k = i;
for (int j = i; j < n; ++j)
{
while (n > k && a[i] + a[j] > a[k])
++k;
answer += k - j;
}
}
return answer;
}
反对者更新：
这绝对是 O(n^2)！请仔细阅读 Thomas H. Cormen 关于摊销分析的“算法介绍”一章（第二版中的 17.2）。 有时通过计算嵌套循环来发现复杂性是完全错误的。 在这里，我尝试尽可能简单地解释它。让我们修复 i 变量。然后对于那个 i 我们必须将 j 从 i 迭代到 n （这意味着 O(n) 操作）和内部 while 循环将 k 从 i 迭代到 n （这也意味着 O(n) 操作）。 注意：对于每个 j，我不会从头开始 while 循环。我们还需要对从 0 到 n 的每个 i 执行此操作。所以它给了我们 n * (O(n) + O(n)) = O(n^2)。
【讨论】：
O(n^2*logn)中有一个简单的算法。
(a, b, c) 其中a <= b <= c。a + b > c 就足够了（其他则微不足道）。现在：
O(n * logn)中的序列进行排序，例如通过合并排序。(a, b), a <= b，剩余值 c 必须至少为 b 且小于 a + b。[b, a+b)的项目数。这可以简单地通过对 a+b (O(logn)) 进行二进制搜索并计算 [b,a+b) 中的项目数来获得 b-a 的每种可能性。
一起O(n * logn + n^2 * logn) 即O(n^2 * logn)。希望这会有所帮助。
【讨论】：
如果你使用二进制排序，那就是 O(n-log(n))，对吧？把你的二叉树放在手边，对于每一对 (a,b)，其中 a b 和 c
【讨论】：
O(n-log(n)) 的东西不正确。
设a、b、c为三个边。三角形必须满足以下条件（两条边之和大于第三条边）
i) a + b > c
ii) b + c > a
iii) a + c > b
以下是计算三角形的步骤。
按非降序对数组进行排序。
将两个指针‘i’和‘j’分别初始化为第一个和第二个元素，并将三角形的计数初始化为0。
修复 'i' 和 'j' 并找到最右边的索引 'k'（或最大的 'arr[k]'）使得 'arr[i] + arr[j] > arr[k]' .以'arr[i]'和'arr[j]'作为两侧可以形成的三角形的数量是'k - j'。将“k - j”添加到三角形计数中。
让我们将“arr[i]”视为“a”，将“arr[j]”视为b，将“arr[j+1]”和“arr[k]”之间的所有元素视为“c”。由于‘arr[i]
4.增加'j'以再次修复第二个元素。
请注意，在第 3 步中，我们可以使用之前的“k”值。原因很简单，如果我们知道'arr[i] + arr[j-1]'的值大于'arr[k]'，那么我们可以说'arr[i] + arr[j]'也将大于 'arr[k]'，因为数组是按升序排序的。
5.如果‘j’已经结束，则增加‘i’。将‘j’初始化为‘i+1’，‘k’初始化为‘i+2’，重复步骤3和4。
时间复杂度： O(n^2)。 由于 3 个嵌套循环，时间复杂度看起来更高。如果我们仔细观察算法，我们会发现 k 在最外层循环中只被初始化一次。对于最外层循环的每次迭代，最内层循环最多执行 O(n) 时间，因为对于 j 的所有值，k 从 i+2 开始并上升到 n。因此，时间复杂度为O(n^2)。
【讨论】：
我已经制定了一个在 O(n^2 lgn) 时间内运行的算法。我认为它是正确的... 代码是用 C++ 编写的...
int Search_Closest(A,p,q,n) /*Returns the index of the element closest to n in array
A[p..q]*/
{
if(p<q)
{
int r = (p+q)/2;
if(n==A[r])
return r;
if(p==r)
return r;
if(n<A[r])
Search_Closest(A,p,r,n);
else
Search_Closest(A,r,q,n);
}
else
return p;
}
int no_of_triangles(A,p,q) /*Returns the no of triangles possible in A[p..q]*/
{
int sum = 0;
Quicksort(A,p,q); //Sorts the array A[p..q] in O(nlgn) expected case time
for(int i=p;i<=q;i++)
for(int j =i+1;j<=q;j++)
{
int c = A[i]+A[j];
int k = Search_Closest(A,j,q,c);
/* no of triangles formed with A[i] and A[j] as two sides is (k+1)-2 if A[k] is small or equal to c else its (k+1)-3. As index starts from zero we need to add 1 to the value*/
if(A[k]>c)
sum+=k-2;
else
sum+=k-1;
}
return sum;
}
希望对你有帮助......
【讨论】：
虽然我们可以使用二分搜索来找到 'k' 的值，从而提高时间复杂度！
【讨论】：
N0,N1,N2,...Nn-1
sort
X0,X1,X2,...Xn-1 as X0>=X1>=X2>=...>=Xn-1
choice X0(to Xn-3) and choice form rest two item x1...
choice case of (X0,X1,X2)
check(X0<X1+X2)
OK is find and continue
NG is skip choice rest
【讨论】：
似乎没有比 O(n^3) 更好的算法了。在最坏的情况下，结果集本身有 O(n^3) 个元素。
例如，如果给定 n 个相等的数字，则算法必须返回 n*(n-1)*(n-2) 个结果。
【讨论】：