分割字符串

题目

 题目分析

1.先确定用容器存储，容器的存储结构如下图所示：

 2.这个题目的话，第一反应应该是用到动态规划，下面是动态规划的模板：

res = []
ans = []

def backtrack(未探索区域, res, path):
    if 未探索区域满足结束条件:
        res.add(ans) # 深度拷贝
        return
    for 选择 in 未探索区域当前可能的选择:
        if 当前选择符合要求:
            path.add(当前选择)
            backtrack(新的未探索区域, res, ans)
            path.pop()

如果发现字符串为空，则直接加入res，因为空字符串一定是回文字符串。

如果不为空，则使用substr函数，进行字符串提取，再加入回文字符串判断，如果是回文字符串，则加入ans，然后继续处理剩下部分

// 回溯函数，用于生成所有回文子串的组合  
void backtrack(const string& s, int start, vector<vector<string>>& res, vector<string>& ans) 
{
    if (start == s.size())//空字符串 
    {
        res.push_back(ans); // 将当前组合添加到结果中  
        return;
    }

    for (int i = start; i < s.size(); ++i) 
    {
        string str1 = s.substr(start, i - start + 1);
        if (isPalindrome(str1)) 
        {
            ans.push_back(str1); // 将当前回文子串添加到当前组合中  
            backtrack(s, i + 1, res, ans); // 递归处理剩余部分  
            ans.pop_back(); // 回溯，移除当前回文子串以尝试其他组合  
        }
    }
}

3.这里需要处理回文串。回文字符串：是一个正读和反读都一样的字符串。

下面是回文串的判断：

bool isPalindrome(const string& s) 
{
    int start = 0;
    int end = s.size() - 1;
    while (start < end) 
    {
        if (s[start] != s[end]) 
        {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

代码

普通代码

#include<iostream>  
#include<vector>  
#include<string>  

using namespace std;

// 检查是否为回文串  
bool isPalindrome(const string& s) 
{
    int start = 0;
    int end = s.size() - 1;
    while (start < end) 
    {
        if (s[start] != s[end]) 
        {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

// 回溯函数，用于生成所有回文子串的组合  
void backtrack(const string& s, int start, vector<vector<string>>& res, vector<string>& ans) 
{
    if (start == s.size())//空字符串 
    {
        res.push_back(ans); // 将当前组合添加到结果中  
        return;
    }

    for (int i = start; i < s.size(); ++i) 
    {
        string str1 = s.substr(start, i - start + 1);
        if (isPalindrome(str1)) 
        {
            ans.push_back(str1); // 将当前回文子串添加到当前组合中  
            backtrack(s, i + 1, res, ans); // 递归处理剩余部分  
            ans.pop_back(); // 回溯，移除当前回文子串以尝试其他组合  
        }
    }
}

// 主函数，用于生成给定字符串的所有回文子串组合  
vector<vector<string>> generatePalindromeSubstrings(const string& s) 
{
    vector<vector<string>> res;
    vector<string> ans;

    backtrack(s, 0, res, ans);
    return res;
}

int main() 
{
    string s;
    cin >> s;

    vector<vector<string>> results = generatePalindromeSubstrings(s);

    for (const auto& combo : results) 
    {
        for (const auto& str : combo) 
        {
            cout << str << " ";
        }
        cout << endl;
    }

    return 0;
}

力扣代码

class Solution {
public:

    bool isPalindrome(const string& s) 
    {
        int start = 0;
        int end = s.size() - 1;
        while (start < end) 
        {
            if (s[start] != s[end]) 
            {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }

    void backtrack(const string& s, int start, vector<vector<string>>& res, vector<string>& ans) 
    {
        if (start == s.size()) 
        {
            res.push_back(ans); // 将当前组合添加到结果中  
            return;
        }

        for (int i = start; i < s.size(); ++i) 
        {
            string str1 = s.substr(start, i - start + 1);
            if (isPalindrome(str1)) 
            {
                ans.push_back(str1); // 将当前回文子串添加到当前组合中  
                backtrack(s, i + 1, res, ans); // 递归处理剩余部分  
                ans.pop_back(); // 回溯，移除当前回文子串以尝试其他组合  
            }
        }
    }

    vector<vector<string>> generatePalindromeSubstrings(const string& s) 
    {
        vector<vector<string>> res;
        vector<string> ans;

        backtrack(s, 0, res, ans);
        return res;
    }

    vector<vector<string>> partition(string s) 
    {
        vector<vector<string>> results = generatePalindromeSubstrings(s);

        return results;
    }
};