Time complexity 以下函数的时间复杂度是多少？

我正在读一本关于竞争编程的书，遇到了一个问题，我们必须计算

n*n

矩阵中所有可能的路径。 现在的条件是： `

现在，这是我的问题代码：

typedef long long ll;
ll path_count(ll n,vector<vector<bool>>& done,ll r,ll c){
    ll count=0;
    done[r][c] = true;
    if(r==(n-1) && c==(n-1)){
        for(ll i=0;i<n;i++){
            for(ll j=0;j<n;j++) if(!done[i][j]) {
                done[r][c]=false;
                return 0;
            }
        }
        count++;
    }
    else {
        if((r+1)<n && !done[r+1][c]) count+=path_count(n,done,r+1,c);
        if((r-1)>=0 && !done[r-1][c]) count+=path_count(n,done,r-1,c);
        if((c+1)<n && !done[r][c+1]) count+=path_count(n,done,r,c+1);
        if((c-1)>=0 && !done[r][c-1]) count+=path_count(n,done,r,c-1);
    }
    done[r][c] = false;
    return count;
}

typedef long ll；
ll path_计数（ll n、向量和完成、ll r、ll c）{
ll计数=0；
完成[r][c]=正确；
如果（r==（n-1）和&c==（n-1））{
对于（ll i=0；iNo），复杂性不是
O（4^n*n^2）

考虑你的符号中的
4^n
。这意味着，在你的情况下，深度最多为
n
-或7，每个级别有4个选择。但事实并非如此。在第8个级别，你仍然有多个选择下一步去哪里。事实上，你正在分支，直到找到深度
n^2
的路径

因此，一个非紧边界将为我们提供
O（4^（n^2）*n^2）
。然而，这个边界远不是紧的，因为它假设您在每个递归调用中有4个有效的选择。事实并非如此

我不确定它能有多紧，但是第一次尝试会把它降到
O（3^（n^2）*n^2）
，因为你不能从你来自的节点出发。这个界限仍然远远不是最优的。
所以这意味着每个调用都可以进行atmost O（n^2）调用…这是有意义的。如果我错了，请纠正我。实际上，每个调用都不是O（n^4），但最底层是，在指数增长中，这足以影响所有人。
typedef long long ll;
ll path_count(ll n,vector<vector<bool>>& done,ll r,ll c){
    ll count=0;
    done[r][c] = true;
    if(r==(n-1) && c==(n-1)){
        for(ll i=0;i<n;i++){
            for(ll j=0;j<n;j++) if(!done[i][j]) {
                done[r][c]=false;
                return 0;
            }
        }
        count++;
    }
    else {
        if((r+1)<n && !done[r+1][c]) count+=path_count(n,done,r+1,c);
        if((r-1)>=0 && !done[r-1][c]) count+=path_count(n,done,r-1,c);
        if((c+1)<n && !done[r][c+1]) count+=path_count(n,done,r,c+1);
        if((c-1)>=0 && !done[r][c-1]) count+=path_count(n,done,r,c-1);
    }
    done[r][c] = false;
    return count;
}