Java O（n！）的例子？

O（n！）

函数的示例（代码中）是什么？参考

n

，它应该采取适当数量的操作来运行；也就是说，我问的是时间复杂性。

一个经典的例子是通过蛮力搜索

---

如果有

N

城市，蛮力方法将尝试这些

N

城市的每一个排列，以找出哪一个最便宜。现在

N

城市的排列数是

N使其成为复杂性的阶乘（
O（N！）
）。
好了。这可能是在
O（n！）
时间内运行的函数的最简单示例（其中
n
是函数的参数）：

void nFacRuntimeFunc（int n）{
对于（inti=0；i最简单的示例：）

伪代码：

input N
calculate N! and store the value in a vaiable NFac - this operation is o(N)
loop from 1 to NFac and output the letter 'z' - this is O(N!)

好了：）

作为一个真实的例子-如何生成一组项的所有排列？
通过子项展开查找行列式

很好的解释

#包括
#包括
小调舞曲
{bool ok=true；
//矩阵的维数
尺寸n=3；
//构造确定性对象
CppAD：：按次测定（n）；
双a[]={
1,2,3.，//a[0]a[1]a[2]
3,2,1.，//a[3]a[4]a[5]
2,1,2//a[6]a[7]a[8]
};
CPPAD_测试向量A（9）；
尺寸i；
对于（i=0；i<9；i++）
A[i]=A[i]；
//评估行列式
双检测器=检测器（A）；
复核；
检查=a[0]*（a[4]*a[8]-a[5]*a[7]）
-a[1]*（a[3]*a[8]-a[5]*a[6]）
+a[2]*（a[3]*a[7]-a[4]*a[6]）；
确定=检测=检查；
返回ok；
}

您还将找到必要的.hpp文件。
存在问题，这些问题是（可在不确定多项式时间内验证）。这意味着如果输入缩放，则解决问题所需的计算量会增加很多

一些NP难的问题是：（），（）

一些NP完全的问题是：（），（），（），（），（），（），（），（），（），（），（），（），（），（），（），（），（），等等

资料来源：



来源：
请参阅本文的一节

根据这篇文章，在维基百科中，通过暴力搜索解决问题和使用查找都是O（n！）。

用蛮力搜索法求解旅行商问题；用未成年人展开法求行列式

是我遇到的唯一一个冒险进入O（n！）区域的“官方”算法。但它不是一个保证的O（n！），因为它本质上是随机的。
我想我有点晚了，但我发现这是O（n！）确定性算法的最佳示例。它基本上会找到数组的下一个排列，直到对其排序为止

看起来是这样的：

template <class Iter> 
void snail_sort(Iter first, Iter last)
{
    while (next_permutation(first, last)) {}
}

模板
无效蜗牛排序（Iter优先，Iter最后）
{
while（next_置换（first，last））{}
}
你可能学过的获取矩阵行列式的递归方法（如果你学习线性代数的话）需要O（n！）时间。尽管我并不特别想把它们全部编码起来。
任何计算给定数组所有排列的算法都是
O（n！）
C语言#

这在空间复杂性上不是O（N！）吗？因为C#中的字符串是不可变的

string reverseString(string orgString) {
    string reversedString = String.Empty;

    for (int i = 0; i < orgString.Length; i++) {
        reversedString += orgString[i];
    }

    return reversedString;
}

字符串反转字符串（字符串或字符串）{
string reversedString=string.Empty；
for（int i=0；i
printf（“你好世界”）；

是的，这是O（n！）。如果你认为不是，我建议你阅读BigOh的定义

我之所以加上这个答案，是因为人们有一个恼人的习惯，那就是不管他们的实际意思是什么，总是要使用BigOh

例如，我很确定这个问题的目的是问θ（n！），对于某些常数c，c>0，至少是cn！步，不超过cn！步，但选择使用O（n！）

另一个例子：
Quicksort在最坏的情况下是O（n^2）
，虽然技术上是正确的（即使heapsort在最坏的情况下也是O（n^2！），但实际上他们的意思是
Quicksort在最坏的情况下是ω（n^2）
@clocksmith你绝对正确。这不是在计算n！。也不是O（n！）。我运行它收集了下表中的数据。请比较第2列和第3列。（#nF是对nFacRuntimeFunc的调用数）

n#nF n！
显然，if的性能比O（n！）差得多。下面是递归计算n！的示例代码。您会注意到它的顺序是O（n！）

你是对的，递归调用应该正好需要n！个时间。下面是一个类似于测试n个不同值的阶乘时间的代码。对于j的不同值，内部循环运行n！个时间，因此内部循环的复杂性很大O（n！）

时间复杂度为n的精确函数

// Big O(n!)
public static void NFactorialRuntime(int n)
    {
        for (int j = 1; j <= Fact(i); j++) {  ++x; }
        Console.WriteLine(" {0}   {1}   {2}", i, x, f);
    }

//大O（n！）
公共静态无效NFactorialRuntime（int n）
{
对于（int j=1；j加上k函数
这是一个复杂度为O（n！）的函数的简单示例，给定一个参数为int的数组和一个整数k。如果数组x+y=k中有两个项，则返回true，例如：如果tab为[1,2,3,4]且k=6，则返回值为true，因为2+4=6

public boolean addToUpK(int[] tab, int k) {

        boolean response = false;

        for(int i=0; i<tab.length; i++) {

            for(int j=i+1; j<tab.length; j++) {

                if(tab[i]+tab[j]==k) {
                    return true;
                }

            }

        }
        return response;
    }

你是说Ω（n！）[渐近增长的下限]或“与n成比例的时间！”[上限和下限]，而不是O（n！）[渐近增长的上限]。因为O（n！）只是上限，所以很多算法都是O（n！），因为它们是O（n）或O（n log n）或O（1）或者类似的。我没有DV，但可能是因为它没有示例代码，并且没有提供大o符号…@aioobe:因为问题是“什么是o（n！）问题”，答案是“这里有一个”，我认为你不必说o（n！））明确地设想3个城市。要检查任何可能的路线，你必须检查两个城市之间的距离两次。A->B an
0    0      1
1    1      1
2    4      2
3    15     6
4    65     24
5    325    120
6    1956   720
7    13699  5040

int Factorial(int n)
{
   if (n == 1)
      return 1;
   else
      return n * Factorial(n-1);
}

public static void NFactorialRuntime(int n)
    {
        Console.WriteLine(" N   Fn   N!");
        for (int i = 1; i <= n; i++)  // This loop is just to test n different values
        {
            int f = Fact(i);
            for (int j = 1; j <= f; j++)  // This is Factorial times
            {  ++x; }
            Console.WriteLine(" {0}   {1}   {2}", i, x, f);
            x = 0;
        }
    }

  N   Fn   N!
  1   1   1
  2   2   2
  3   6   6
  4   24   24
  5   120   120

// Big O(n!)
public static void NFactorialRuntime(int n)
    {
        for (int j = 1; j <= Fact(i); j++) {  ++x; }
        Console.WriteLine(" {0}   {1}   {2}", i, x, f);
    }

public boolean addToUpK(int[] tab, int k) {

        boolean response = false;

        for(int i=0; i<tab.length; i++) {

            for(int j=i+1; j<tab.length; j++) {

                if(tab[i]+tab[j]==k) {
                    return true;
                }

            }

        }
        return response;
    }

@Test
    public void testAddToUpK() {

        DailyCodingProblem daProblem = new DailyCodingProblemImpl();

        int tab[] = {10, 15, 3, 7};
        int k = 17;
        boolean result = true; //expected result because 10+7=17
        assertTrue("expected value is true", daProblem.addToUpK(tab, k) == result);

        k = 50;
        result = false; //expected value because there's any two numbers from the list add up to 50
        assertTrue("expected value is false", daProblem.addToUpK(tab, k) == result);
    }