Java for循环内部递归的时间复杂性

你能帮我解释一下这段代码的时间复杂性吗。我想是3^n，但我是个新手，所以我可能错了

public void find(int n) throws Exception
    {
        if (n == vertices){
            throw new Exception("Solution found");
        }

        for (int r = 1; r <= 3; r++)
        {
            if (control(n, r))
            {

                color[n] = r;
                find(n + 1);

                color[n] = 0;
            }
        }    
    }

    public boolean control(int n, int r)
    {
        for (int i = 0; i < vertices; i++){
            if (graph[n][i] == 1 && r == color[i]){
                return false;
            }
        }
        return true;
    }

public void find（int n）引发异常
{
如果（n==顶点）{
抛出新异常（“找到解决方案”）；
}
对于（int r=1；r
因此，似乎每个节点上都有总的，
3^1+3^2+…+3^顶点
节点，并且在每个节点上执行
O（n）
操作。因此复杂性是
O（（3^1+3^2+…+3^n）*n）
=
O（（1-3^n）/2）*n）
最终
O（（3^顶点）*顶点）

编辑：当基本条件未引发异常时，此选项适用

控件
方法有一个循环，该循环在
顶点
上运行多次，因此它是
O（顶点）

find
是一个递归函数，当
n
到达
顶点时停止（假设
n
从1开始），它为n=1,2,3…顶点调用
控件

find
从循环中调用3次。每次递归调用都涉及到这一点，因此这使它成为指数-
O（3^顶点）

因此，最后是
O（3^顶点）
*
O（顶点）
，这是
O（3^顶点）

编辑：

既然您已经抛出了新的异常（“找到了解决方案”）；

，那么一旦

n

到达顶点，它就会爆炸。这样的话就是

O（顶点^2）

。

这是家庭作业还是某种作业？为什么您认为它是

O（3^n）

？如果不查看

控制

和

查找

方法，就不可能回答。如果你在做一个函数，它是

O（n）

三次，那不是

3^n

-它仍然是

O（n）

。不过，告诉“找到解决方案”的有趣方式。我真的找不到另一种退出该方法的有效方法，所以我使用了异常。这可能是非常错误的，而不是它的目的。@lexicore我说的部分是正确的，当递归调用在loop@user7我不明白为什么。

find

一次最多调用

control

D<代码>最多查找一次< /COD>一次，不会是代码>顶点（3×顶点）< /代码>即<代码> o（顶点^ 2）< /Cord>？@ ListCiORE，你怎么说“代码>查找< /COD>最多重复一次？一旦命中了基础条件，你会考虑<代码> R= 2,2,3/COD>（假设基本条件不会像OP那样抛出异常）；)@因此，我错过了

抛出异常

部分。因此您认为？在这种情况下

最多3次查找调用控件

是不对的。因为循环在每次递归中最多运行一次call@user7你是对的。我错了。如果

graph[n][I]

始终是

0

，它将重复出现3次。我一直在思考这一点，我很好奇。抛出的异常被捕获的事实是否会改变其复杂性？或者异常是否会阻止它在任何情况下进一步发展，并且无论发生什么都是O（顶点^2）。抱歉，我不得不问。如果你捕获异常并忽略它（或不抛出异常）对于

r

（

2,3

）的其他值，递归将继续进行。哦，我的代码捕获了我本应该显示的异常。抱歉，没有。在

find

之外捕获不会有任何影响。它仍然是O（顶点^2）。

       n
      /|\
     / | \ 
    /  |  \
   /   |   \
(n+1) (n+1)(n+1) --> control(vertex)-> O(Vertex)
 /|\
/ | \ . . . .   . .