Leetcode Day6 分割回文子字符串+复原IP

理想国の糕

于 2023-03-07 21:04:24 发布

阅读量135

点赞数

分类专栏：算法笔记入门文章标签： leetcode 深度优先算法

本文链接：https://blog.csdn.net/qq_45751990/article/details/129389930

版权

算法笔记入门专栏收录该内容

88 篇文章 4 订阅

订阅专栏

文章介绍了两种使用深度优先搜索（DFS）解决的字符串处理问题：一是将给定字符串分割成回文子字符串的所有可能方案，二是从数字字符串中恢复有效IP地址。在回文子字符串问题中，通过检查字符串的连续子串是否为回文并进行递归切割实现。在IP地址复原问题中，确保每个部分在0到255之间且无前导零，同样利用DFS进行搜索。

摘要由CSDN通过智能技术生成

1、分割回文子字符串

给定一个字符串 s ，请将 s 分割成一些子串，使每个子串都是回文串，返回 s 所有可能的分割方案。
回文串是正着读和反着读都一样的字符串。
【传送门】

需要注意的是string.substr(a,b)中a表示需要截取的字符串的首位位置，b表示截取的子字符串的长度

思路：常见的DFS的问题，搜索的两个参数分别是截取字符串的首位和末尾位置，要注意字符串的连续性

class Solution {
public:
    string str;
    int len;
    vector<string>temp;
    vector<vector<string>>ans;
    bool isPalindromes(int left,int right){
        if(left==right){
            return true;
        }
        //left-right
        //left+1,right-1
        for(int i=0;;i++){
            if(left+i>=right-i){
                break;
            }
            if(str[left+i]!=str[right-i]){
                return false;
            }
        }
        return true;
    }
    void dfs_cut(int left,int right){
        temp.emplace_back(str.substr(left,right-left+1));
        if(right==len-1){
            ans.emplace_back(temp);
            
        }else{
           for(int r=right+1;r<len;r++){
                if(isPalindromes(right+1, r)){
                    dfs_cut(right+1, r);
                    temp.pop_back();
                }
                
            } 
        }
        
    }
    vector<vector<string>> partition(string s) {
        len=s.length();
        str=s;
        
        for(int right=0;right<len;right++){
            if(isPalindromes(0, right)){
                dfs_cut(0,right);
                temp.pop_back();
            }
                
        }
        return ans;
    }
};

2、复原IP

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能从 s 获得的有效 IP 地址。你可以按任何顺序返回答案。
有效 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是无效 IP 地址。
【传送门】

思路：实际上还是一道DFS的搜索问题，考察的还是对于给定字符串的合法切割问题，可以参考上一题的思路解法，唯一要注意的是以字符串形式保存每次遍历后成为答案的结果——也就是IP串

class Solution {
public:
    string str;
    int len;
    vector<string>temp;
    vector<string>ans;
    void dfs(int left,int right){
        if(left>=len||right>=len){

        }else if(right-left+1>1&&str[left]=='0'){
            
        }else{
            string sub=str.substr(left,right-left+1);
            int num;
            sscanf(sub.c_str(), "%d", &num);
            if(num<=255){
                temp.emplace_back(sub);
                if(temp.size()==4){
                    string tstr="";
                    for(int i=0;i<4;i++){
                        if(i){
                            tstr+=".";
                        }
                        tstr+=temp[i];
                    }
                    if(right==len-1){
                        ans.emplace_back(tstr);
                    }
                }else if(temp.size()<4){
                    for(int l=1;l<=3;l++){
                       
                        dfs(right+1,right+l);
                        
                    }
                }
                temp.pop_back();
            } 
        }
        
    }
    
    vector<string> restoreIpAddresses(string s) {
        //DFS
        str=s;
        len=str.length();
        for(int r=0;r<3;r++){
            dfs(0,r);
        }
        return ans;
    }
};