如何计算非标准日常算法的复杂度答案

【问题标题】：How to calculate complexity of non-standard day to day algorithms如何计算非标准日常算法的复杂度
【发布时间】：2018-03-08 08:30:01
【问题描述】：

你好 StackOverflow 社区！

这么多天我一直在想这个问题，最后决定解决它。那么，给定一个算法，或者说一个函数在你的日常编码活动中实现了一些非标准算法，你如何分析朗姆酒时间复杂度？

好的，让我更具体一点。假设你正在解决这个问题，

给定一个由正整数组成的 NxN 矩阵，找出其中最长的递增序列。您只能向上、向下、向左或向右移动，但不能沿对角线移动。

例如：如果矩阵是

  [ [9,9,4], 
    [6,6,8], 
    [2,1,1] ].

算法必须返回 4

（序列为1->2->6->9）

是的，看来我必须使用 DFS。我明白这部分。我已经在 Uni 完成了我的算法课程，并且可以解决这些问题。所以，我想出了这个解决方案说，

class Solution
{   
    public int longestIncreasingPathStarting(int[][] matrix, int i, int j)
    {
        int localMax = 1;
        int[][] offsets = {{0,1}, {0,-1}, {1,0}, {-1,0}};

        for (int[] offset: offsets)
        {
            int x = i + offset[0];
            int y = j + offset[1];
            if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[i].length || matrix[x][y] <= matrix[i][j])
                continue;
            localMax = Math.max(localMax, 1+longestIncreasingPathStarting(matrix, x, y));
        }
        return localMax;
    } 

    public int longestIncreasingPath(int[][] matrix) 
    {
        if (matrix.length == 0)
            return 0;
        int maxLen = 0;

        for (int i = 0; i < matrix.length; ++i)
        {
            for (int j = 0; j < matrix[i].length; ++j)
            {
                maxLen = Math.max(maxLen, longestIncreasingPathStarting(matrix, i, j));
            }
        }
        return maxLen;
    }
}

效率低下，我知道，但我是故意这样写的！无论如何，我的问题是，您如何分析 longestIncreasingPath(matrix) 函数的运行时间？

我可以理解他们在 Algos 课程中教给我们的分析，你知道标准的 MergeSort、QuickSort 分析等。但不幸的是，我不想这么说，那没有让我准备好应用它在我的日常编码工作中。我现在就想做，因此想从分析这些功能开始。

有人可以在这里帮助我并描述分析上述函数的运行时需要采取的步骤吗？这对我有很大帮助。提前致谢，干杯！

【问题讨论】：

标签： algorithm performance time-complexity big-o code-complexity

【解决方案1】：

对于日常工作，目不转睛的事情通常效果很好。在这种情况下，您将尝试递归地朝各个方向前进。因此，我想到了一个非常糟糕的例子，例如：[[1,2,3], [2,3,4], [3,4,5]] 这样您就可以从大多数单元格中获得两个选项。我碰巧知道这将是 O((2*n) ! / (n!*n!)) 步，但另一个好的猜测是 O(2^N)。既然您有一个示例，您知道或可以更轻松地计算复杂度，那么总体复杂度必须至少是这样。

通常，究竟是哪一个并不重要，因为对于 O(N!) 和 O(2^N)，运行时间增长得非常快，并且只能在 10-20 左右快速工作如果您愿意等待，可能会更多。你不会为 N ~= 1000 运行这个算法，你需要一些多项式。因此，粗略估计您有一个指数解决方案就足以做出决定。

因此，一般而言，要了解复杂性，请尝试将您的解决方案与您已经知道复杂性的其他算法联系起来，或者找出更容易判断复杂性的算法的最坏情况。即使您稍有偏差，它仍可能有助于您做出决定。

如果您需要比较复杂度更相似的算法（即 N~=100 的 O(NlogN) 与 O(N^2)），您应该同时实现和基准测试，因为常数因子可能是导致运行时。

【讨论】：