代码随想录Day20:回溯算法解决切割问题

1.131分割回文串

回溯算法解决分割问题

回文串：即对于任何位置s[i] = s[n-i-1]用isparlidome函数来判断是否为回文串

循环的输入参数：result,path,s为常规的输入参数，left,right可以合并为一个startindex，也是常规的一个输入参数

循环终止条件：即循环到了最后一个

循环内的条件：需要先确定这一段是一个回文串，才能进行回溯算法。

class Solution {
public:
    bool isparlidome(string& p){
        int m = p.size();
        for(int i = 0,j = m-1;i<j;i++,j--){
            if(p[i]!=p[j]){
                return false;
            }
        }
        return true;
    }
    void backtracking(vector<vector<string>>& result,vector<string>& path,string& s,int leftindex,int rightindex){
        if(rightindex == s.size()){
            result.push_back(path);
        }
        for(int i = rightindex;i<s.size();i++){
            string st = s.substr(leftindex,i-leftindex+1);//获得[leftindex,rightindex]的字符串
            if(isparlidome(st)){
                cout<<st<<endl;
                path.push_back(st);
                backtracking(result,path,s,i+1,i+1);
                path.pop_back();
            }else{
                continue;
            }
        }
    }
    vector<vector<string>> partition(string s) {
        vector<vector<string>> result;
        vector<string> path;
        int n = s.size();
        if(n == 0)return result;
        backtracking(result,path,s,0,0);
        return result;

    }
};

2.93复原IP地址

类似于前面的分割回文串，但是分割的条件发生了改变。

1添加了一个dotnum来确定添加了几个段，作为最终的一个终止条件。

2.用isValid来判断这段是否满足为一个0-255的数字

3.有两种方法来进行添加，前面那种是用一个新的path来存储，第二种就是直接在S中进行操作然后添加到result中。

class Solution {
public:
    bool isValid(string&s,int left,int right){
        if(left>right){
            return false;
        }
        if(s[left]=='0'&&left!=right){
            return false;
        }
        int count = 0;
        for(int i = left;i<=right;i++){
            if(s[i]>'9'||s[i]<'0'){return false;}//判断是否为数字
            count = count*10 + s[i]-'0';
            if(count>255){//判断是否超出范围
                return false;
            }
        }
        return true;
    }
    //分割问题
    void backtracking(vector<string>& result,string& path,int startIndex,string& s,int dotnum){
        if(path.size() == s.size()+3&&dotnum == 3){//加点之后的长度为n+4
            result.push_back(path);
            return;
        }
        if(dotnum>3){
            return;
        }
        for(int i = startIndex;i<s.size();i++){
            if(isValid(s,startIndex,i)){
                path += s.substr(startIndex,i-startIndex+1);
                if(i != s.size()-1){
                    path += ".";
                    dotnum++;
                }
                backtracking(result,path,i+1,s,dotnum);
                if(i != s.size()-1){
                    path.erase(path.size()-1);
                    dotnum--;
                }
                path.erase(path.size()-(i-startIndex+1));
            }else{
                break;
            }
        }
        return;
    }
    vector<string> restoreIpAddresses(string s) {
        vector<string> result;
        string path;
        backtracking(result,path,0,s,0);
        return result;
    }
};

    //分割问题
    void backtracking(vector<string>& result,int startIndex,string& s,int dotnum){
        if(dotnum == 3){
            if(isValid(s,startIndex,s.size()-1)){
                result.push_back(s);
            }
            return;
        }
        for(int i=startIndex;i<s.size();i++){
            if(isValid(s,startIndex,i)){
                s.insert(s.begin()+i+1,'.');//插入一个逗号
                dotnum++;
                backtracking(result,i+2,s,dotnum);
                dotnum--;
                s.erase(s.begin()+i+1);
            }else{
                break;
            }
        }
    }