LeetCode Solutions

Time: $O(3^4)$

Space: $O(1)$

			

class Solution {
 public:
  vector<string> restoreIpAddresses(const string& s) {
    vector<string> ans;
    dfs(s, 0, {}, ans);
    return ans;
  }

 private:
  void dfs(const string& s, int start, vector<string>&& path,
           vector<string>& ans) {
    if (path.size() == 4 && start == s.length()) {
      ans.push_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
      return;
    }
    if (path.size() == 4 || start == s.length())
      return;

    for (int length = 1; length <= 3; ++length) {
      if (start + length > s.length())
        return;  // Out of bound
      if (length > 1 && s[start] == '0')
        return;  // Leading '0'
      const string& num = s.substr(start, length);
      if (stoi(num) > 255)
        return;
      path.push_back(num);
      dfs(s, start + length, move(path), ans);
      path.pop_back();
    }
  }
};

			

class Solution {
  public List<String> restoreIpAddresses(final String s) {
    List<String> ans = new ArrayList<>();
    dfs(s, 0, new ArrayList<>(), ans);
    return ans;
  }

  private void dfs(final String s, int start, List<String> path, List<String> ans) {
    if (path.size() == 4 && start == s.length()) {
      ans.add(String.join(".", path));
      return;
    }
    if (path.size() == 4 || start == s.length())
      return;

    for (int length = 1; length <= 3; ++length) {
      if (start + length > s.length()) // Out of bound
        return;
      if (length > 1 && s.charAt(start) == '0') // Leading '0'
        return;
      final String num = s.substring(start, start + length);
      if (Integer.parseInt(num) > 255)
        return;
      path.add(num);
      dfs(s, start + length, path, ans);
      path.remove(path.size() - 1);
    }
  }
}

			

class Solution:
  def restoreIpAddresses(self, s: str) -> List[str]:
    ans = []

    def dfs(start: int, path: List[int]) -> None:
      if len(path) == 4 and start == len(s):
        ans.append(path[0] + '.' + path[1] + '.' + path[2] + '.' + path[3])
        return
      if len(path) == 4 or start == len(s):
        return

      for length in range(1, 4):
        if start + length > len(s):
          return  # Out of bound
        if length > 1 and s[start] == '0':
          return  # Leading '0'
        num = s[start: start + length]
        if int(num) > 255:
          return
        dfs(start + length, path + [num])

    dfs(0, [])
    return ans