Algorithm for循环内部递归的复杂性

我试图分析这个算法的复杂性，我预测它是

t（n）=n*t（n）+1

，并通过主定理

n^logn

求解

t（n）

。然而，我不确定，并坚持下去

  Algorithm CheckPath(m[0..n-1][0..n-1],v1,v2)
       if v1==v2
       return 0
   cost = 0
   for i = 0 to n-1
     if  m[v1]m[v2]!=0 //any path exits
       cost2 = m[v1]m[v2]+checkpath(m,i,v2)
       if cost2<cost OR cost==0
         cost = cost2
return cost

算法校验路径（m[0..n-1][0..n-1]，v1，v2）
如果v1==v2
返回0
成本=0
对于i=0到n-1
如果m[v1]m[v2]=0//任何路径都存在
成本2=m[v1]m[v2]+校验路径（m，i，v2）
如果成本2我认为你的方法是错误的。你有一个算法，它运行在一些图上。因此，试着在底层图上发现它的复杂性，而不是在运行的递归上

但为了回答您最初的问题，您的递归具有指数复杂性（并且可能不会终止），除非您的图是DAG（有向无环图）。这样做的原因是您没有将已经到达的顶点标记为这样。因此，递归可以在两个顶点u和v之间无限循环，使得边（u，v）和（v，u）在E中（或者简单地说，如果图形没有方向，那么任何边都会导致这种情况）。
对我来说，这似乎是：

t(n)   = 1 + t(1) + t(2) + ... + t(n-3) + t(n-2) + t(n-1) 
t(n-1) = 1 + t(1) + t(2) + ... + t(n-3) + t(n-2)
t(n-2) = 1 + t(1) + t(2) + ... + t(n-3)
...
t(4) = 1 + t(1) + t(2) + t(3) = 8
t(3) = 1 + t(1) + t(2) = 4
t(2) = 1 + t(1) = 2
t(1) = 1 

查看序列的前几个成员，看起来闭合形式是
t（n）=2^（n-1）

我们能用归纳法证明这一点吗

对于
n==1
我们有
t（1）=2^（1-1）=1
假设每个
k
都有
t（k）=2^（k-1）
。
然后：

因此，
T（n）=O（2^n）
你的意思是m[v1]m[v2]的m[v1][v2]？
n*T（n）+1
是未定义的（递归公式保持在n），可能意味着
n*T（n-1）
，这更像
O（n！）
在哪里定义了成本2？请更正伪代码。
t(n) = 1 + t(1) + t(2) + ... + t(n-1) = 1 + 2^0 + 2 + 4 + ... + 2^(n-2) = 2^(n-1)