Time complexity 这个LC问题的时间复杂度是多少

有人能带我完成这个问题的时间复杂性分析吗？

我有一个使用DFS+backtracking+DP的解决方案，如下所示，我想就时间复杂度而言，它可以归结为在worts情况下您可以拥有的分区数，但我很难弄清楚它是什么

class Solution {
public:
    vector<string> cur;
    vector<vector<string>> ans;
    vector<vector<bool>> isPalindrome;
    unordered_map<int,vector<int>> pairs;

    vector<vector<string>> partition(string s) {
        isPalindrome.resize(s.length(),vector<bool>(s.length(),false));
        buildPalindromePairs(s);
        backtracking(s,0);
        return ans;
    }

    void buildPalindromePairs(string s)
    {
        for(int i=0;i<s.length();++i)
        {
            for(int j=i;j>=0;j--)
            {
                if(i==j) 
                    isPalindrome[j][i]=true;
                else if(j==i-1 && s[j]==s[i]) 
                    isPalindrome[j][i]=true;
                else if(s[j]==s[i] && isPalindrome[j+1][i-1])
                    isPalindrome[j][i]=true;

                if(isPalindrome[j][i])
                    pairs[j].push_back(i);
            }
        }
    }

    void backtracking(string s, int start)
    {
        if(start==s.length()) 
        {
            ans.push_back(cur);
            return;
        }

        for(auto end:pairs[start])
        {
            cur.push_back(s.substr(start, end-start+1));
            backtracking(s,end+1);
            cur.pop_back();
        }
    }
};

类解决方案{
公众：
向量cur；
向量ans；
向量isPalindrome；
无序的_映射对；
向量分区（字符串s）{
resize（s.length（），vector（s.length（），false））；
构建回文对；
回溯（s，0）；
返回ans；
}
无效构建回文对（字符串s）
{
对于（int i=0；i=0；j--）
{
如果（i==j）
isPalindrome[j][i]=真；
else如果（j==i-1&&s[j]==s[i]）
isPalindrome[j][i]=真；
如果（s[j]==s[i]&&isPalindrome[j+1][i-1]）
isPalindrome[j][i]=真；
if（isPalindrome[j][i]）
配对[j].推回（i）；
}
}
}
无效回溯（字符串s，整数开始）
{
如果（开始==s.length（））
{
ans.push_back（cur）；
返回；
}
用于（自动结束：成对[开始]）
{
电流推回（s.substr（开始，结束开始+1））；
回溯（s，end+1）；
cur.pop_back（）；
}
}
};

方法

isAlindrome（）

可以在

O（n）

中解决

方法

buildPalindromePairs（strings）

是

O（n^2）

在嵌套for循环中

方法

void backtracking（string s，int start）

是

O（2^（n-1））

作为您可以选择或不选择的每个字符。所以每个角色有2个选项。因此

n

字符可以理想地呈现

2^n

选项

（2^（n-1））

，因为理想情况下必须有一个字符

---

总体复杂性为

O（2^n）

我认为无效回溯（…）的复杂性不是O（2^（n-1））。这是字符串中所有字符的子集的数量，这不是我们想要的。我们在这里尝试的是对字符串进行不同的分区方式。@devdevev不，是相同的。首先添加它，然后调用backtracking，然后再次弹出它。