力扣，复制IP地址

题目力扣93，复制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 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：

输入：s = "0000"
输出：["0.0.0.0"]
示例 3：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

解题思路

回溯法---切割问题---可以抽象成树形结构

回溯三部曲

1、递归参数
2、递归终止条件
3、单层搜索的逻辑

回溯算法模板

void backTracking(参数)
{
    if(终止条件)
    {
        存放结果;
        return;
    }
    for(选择：本层集合中元素)
    {
        处理节点;
        backTracking(路径，选择列表);//递归
        回溯，撤销处理结;
    }
}

抽象成树形结构，如图

递归参数

startIndex:搜索的起始位置，因为不能重复分割，记录下一层递归分割的起始位置
pointNum:添加逗点的数量
代码如下：

    void backTracking(string& s,int startIndex,int pointNum){
}

递归终止条件

应该将IP地址分割成4段即pointNum=3作为终止条件，并且还要检查第四段是否合法，若合法加入结果集中
代码如下

if(pointNum==3)
{
    if(isValid(s,startIndex,s.size()-1))
    {
        result.push_back(s);
    }
    return;
}

单层搜索逻辑

在for (int i = startIndex; i < s.size(); i++)循环中[startIndex,i]这个区间就是截取的子串，需要判断这个字串是否合法；若合法，就在字符串后面加逗点，表示以及分割。若不合法，结束本层循环，剪枝。
递归：下一层递归的startIndex应该从i+2开始，因为需要在字符串中加入逗点，pointNum++。
回溯：将刚刚加入的分隔符逗点删掉就好了，pointNum--。
代码如下：

for(int i=startIndex;i<s.size();i++)
{
    if(isValid(s,startIndex,i))
    {
        s.insert(s.begin()+i+1,'.');
        pointNum++;
        backtracking(s, i + 2, pointNum);   
        pointNum--;  
        s.erase(s.begin() + i + 1); 
    }
    else
    {
        break;
    }
}

判断子串是否合法

• 段位以0为开头的数字不合法
• 段位里有非正整数字符不合法
• 段位如果大于255不合法
  代码如下：

  // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
  bool isValid(const string& s, int start, int end) {
      if (start > end) {
          return false;
      }
      if (s[start] == '0' && start != end) 
      {
              return false;
      }
      int num = 0;
      for (int i = start; i <= end; i++) {
          if (s[i] > '9' || s[i] < '0') {
              return false;
          }
          num = num * 10 + (s[i] - '0');
          if (num > 255) {
              return false;
          }
      }
      return true;
  }。

  代码

  class Solution {
  public:
      vector<string> result;
      bool isvalid(string &s,int start,int end)
      {
          if(start>end)
          {
              return false;
          }
          if(s[start] == '0' && start != end)
          {
              return false;
          }
          int num=0;
          for(int i=start;i<=end;i++)
          {
              if(s[i]>'9' || s[i]<'0')
              {
                  return false;
              }
              num=num*10+(s[i]-'0');
              if(num>255)
              {
                  return false;
              }
          }
          return true;
      }
  
      void backTracking(string& s,int startIndex,int pointNum)
      {
          if(pointNum==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,'.');
                  pointNum++;
                  backTracking(s,i+2,pointNum);
                  pointNum--;
                  s.erase(s.begin()+i+1);
              }
              else
              {
                  break;
              }
          }
      }
  
      vector<string> restoreIpAddresses(string s) {
          if(s.size() > 12)
          {
              return result;
          }
          backTracking(s,0,0);
          return result;
  
      }
  };