文章目录
93. 复原 IP 地址：样例 1：样例 2：样例 3：提示：
分析：题解：rust：go：c++：python：java：
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 <= s.length <= 20s 仅由数字组成
分析：
面对这道算法题目，二当家的再次陷入了沉思。ip地址大家都是知道的，ipv4是由4段组成，每段的取值范围都是 [0,255]。给出一个ip地址我们都可以判断出是否合法有效，但是现在相当于是反向构建合法有效的ip地址，所以我们就是看字符串有多少种合法ipv4的拆分可能。按照顺序，4段中的每段都可以是1位到3位10进制数，但是不可以有前导0，取值范围是 [0,255]。去尝试所有的可能，看是否恰好拆分成4段有效值，即正好所有的字符都使用了，并且拆分成了4段有效值。祭出深度优先，非常强大的递归套娃大法，更准确地说是回溯算法。注：回溯算法一般需要一个数据结构存储一个临时状态，需要在回溯时还原状态。
题解：
rust：
impl Solution {
pub fn restore_ip_addresses(s: String) -> Vec
fn dfs(s: &str, ans: &mut Vec
// 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
if 4 == segments.len() {
if seg_start == s.len() {
ans.push(segments.join("."));
}
return;
}
// 一般情况，枚举每一种可能性并递归
for seg_end in seg_start + 1..=s.len() {
let segment = &s[seg_start..seg_end];
if (segment.starts_with('0') && (seg_end - seg_start) > 1) || segment.parse::
// 有前导零 或者 地址范围大于255
break;
}
segments.push(segment.to_string());
dfs(s, ans, segments, seg_end);
segments.pop();
}
}
let mut ans = Vec::new();
dfs(s.as_str(), &mut ans, &mut Vec::new(), 0);
return ans;
}
}
go：
func restoreIpAddresses(s string) []string {
var ans []string
var dfs func([]string, int)
dfs = func(segments []string, segStart int) {
// 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
if 4 == len(segments) {
if segStart == len(s) {
ans = append(ans, strings.Join(segments, "."))
}
return
}
// 一般情况，枚举每一种可能性并递归
for segEnd := segStart + 1; segEnd <= len(s); segEnd++ {
segment := s[segStart:segEnd]
addr, _ := strconv.ParseInt(segment, 10, 0)
if (segment[0] == '0' && (segEnd-segStart) > 1) || addr > 0xFF {
// 有前导零 或者 地址范围大于255
break
}
dfs(append(segments, segment), segEnd)
}
}
dfs([]string{}, 0)
return ans
}
c++：
class Solution {
private:
void dfs(const string& s, vector
// 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
if (4 == segIdx) {
if (segStart == s.size()) {
string addr;
for (int i = 0; i < 4; ++i) {
addr += segments[i];
if (i != 3) {
addr += '.';
}
}
ans.emplace_back(addr);
}
return;
}
// 一般情况，枚举每一种可能性并递归
for (int segEnd = segStart + 1; segEnd <= s.size(); ++segEnd) {
string segment = s.substr(segStart, segEnd - segStart);
if ((segment[0] == '0' && (segEnd - segStart) > 1) || stoi(segment) > 0xFF) {
// 有前导零 或者 地址范围大于255
break;
}
segments[segIdx] = segment;
dfs(s, ans, segments, segIdx + 1, segEnd);
}
}
public:
vector
vector
string segments[4];
dfs(s, ans, segments, 0, 0);
return ans;
}
};
python：
class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
ans = list()
def dfs(segments: List[str], seg_start: int):
# 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
if 4 == len(segments):
if seg_start == len(s):
ans.append(".".join(segments))
return
# 一般情况，枚举每一种可能性并递归
for seg_end in range(seg_start + 1, len(s) + 1):
segment = s[seg_start:seg_end]
if (segment[0] == '0' and (seg_end - seg_start) > 1) or int(segment) > 0xFF:
# 有前导零 或者 地址范围大于255
break
segments.append(segment)
dfs(segments, seg_end)
segments.pop()
dfs(list(), 0)
return ans
java：
class Solution {
public List
final List
dfs(s, ans, new String[4], 0, 0);
return ans;
}
private void dfs(String s, List
// 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
if (4 == segIdx) {
if (segStart == s.length()) {
ans.add(String.join(".", segments));
}
return;
}
// 一般情况，枚举每一种可能性并递归
for (int segEnd = segStart + 1; segEnd <= s.length(); ++segEnd) {
String segment = s.substring(segStart, segEnd);
if ((segment.charAt(0) == '0' && (segEnd - segStart) > 1) || Integer.parseInt(segment) > 0xFF) {
// 有前导零 或者 地址范围大于255
break;
}
segments[segIdx] = segment;
dfs(s, ans, segments, segIdx + 1, segEnd);
}
}
}
非常感谢你阅读本文~ 欢迎【点赞】【收藏】【评论】三连走一波~ 放弃不难，但坚持一定很酷~ 希望我们大家都能每天进步一点点~ 本文由 二当家的白帽子：https://le-yi.blog.csdn.net/ 博客原创~
推荐阅读
您阅读本篇文章共花了：
发表评论