From fcf3f21a5249d56a18fcff5603987de4ac0c70b0 Mon Sep 17 00:00:00 2001 From: li-chx Date: Mon, 3 Aug 2026 21:44:25 +0800 Subject: [PATCH] =?UTF-8?q?93.=20=E5=A4=8D=E5=8E=9F=20IP=20=E5=9C=B0?= =?UTF-8?q?=E5=9D=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main.rs | 147 ++++++++++++---------------------------------------- 1 file changed, 32 insertions(+), 115 deletions(-) diff --git a/src/main.rs b/src/main.rs index d77a465..61e5998 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,132 +3,49 @@ use crate::arr::make_matrix; mod arr; struct Solution {} impl Solution { - fn get_ans_from_tree(tree: &Vec, layer_count: usize, l: usize, r: usize) -> usize { - let (cl, cr) = (0, 2_usize.pow(layer_count as u32 - 1) - 1); - Self::dfs(tree, 1, cl, cr, l, r) - } - fn dfs( - tree: &Vec, - root: usize, - l: usize, - r: usize, - target_l: usize, - target_r: usize, - ) -> usize { - if l >= target_l && r <= target_r { - return tree[root] as usize; - } - if l > target_r || r < target_l { - return 0; - } - let from_l = Self::dfs(tree, root * 2, l, (r - l) / 2 + l, target_l, target_r); - let from_r = Self::dfs( - tree, - root * 2 + 1, - (r - l) / 2 + l + 1, - r, - target_l, - target_r, - ); - from_l.max(from_r) - } - pub fn max_active_sections_after_trade(s: String, queries: Vec>) -> Vec { - let arr = s + pub fn restore_ip_addresses(s: String) -> Vec { + let s = s .chars() - .map(|x| -> u8 { x as u8 - b'0' }) - .collect::>(); - let mut zero_start = vec![]; - let mut zero_end = vec![]; - let mut zero_len = vec![]; - // let mut one_count = vec![0]; - let mut one_count = 0; - let mut zero_count = -1; - for i in 0..arr.len() { - if arr[i] == 0 { - // one_count.push(one_count[one_count.len() - 1]); - if zero_count == -1 { - zero_start.push(i); - zero_count = 1; - } else { - zero_count = zero_count + 1; - } - } else { - // one_count.push(one_count[one_count.len() - 1] + 1); - one_count += 1; - if zero_count != -1 { - zero_len.push(zero_count); - zero_end.push(i - 1); - zero_count = -1; - } - } + .map(|c| (c as u8 - '0' as u8) as i32) + .collect::>(); + return Self::dfs(&s, 0, [-1; 4], 0); + } + fn dfs(s: &Vec, cur: usize, mut cur_arr: [i32; 4], cur_st: usize) -> Vec { + if s.len() - cur < 4 - cur_st - if cur_arr[cur_st] == -1 { 0 } else { 1 } + || ((4 - cur_st) * 3 - if cur_arr[cur_st] == -1 {0} else {cur_arr[cur_st].to_string().len()} < s.len() - cur) + { + return vec![]; } - if zero_count != -1 { - zero_len.push(zero_count); - zero_end.push(arr.len() - 1); + if cur >= s.len() + { + return vec![cur_arr.map(|t| t.to_string()).join(".")]; } - - let len = zero_len.len() as f64 - 1f64; - let layer_count = len.log2().ceil() as usize + 1; - let tree_len = 2_usize.pow(layer_count as u32); - let mut tree = vec![0; tree_len]; - let base = 2_usize.pow(layer_count as u32 - 1); - if zero_len.len() > 0 { - for i in 0..zero_len.len() - 1 { - tree[base + i] = zero_len[i] + zero_len[i + 1]; - } - for i in (1..base).rev() { - tree[i] = tree[i * 2].max(tree[i * 2 + 1]); - } + if cur_arr[cur_st] == -1 { + cur_arr[cur_st] = s[cur]; + return Self::dfs(s, cur + 1, cur_arr, cur_st); } - let mut ans = vec![]; - for query in queries { - let (l, r) = (query[0] as usize, query[1] as usize); - // let one = one_count[one_count.len() - 1] - one_count[0]; - let one = one_count; - let i = zero_start.partition_point(|&x| x < l); - let j = zero_end.partition_point(|&x| x <= r); - let mut local_ans = 0; - - if j as i32 - i as i32 >= 2 { - local_ans = local_ans.max(Self::get_ans_from_tree(&tree, layer_count, i, j - 2)); - } - if j as i32 - i as i32 >= 1 { - if i > 0 && i < zero_end.len() { - if zero_end[i - 1] >= l { - let pz = zero_end[i] - zero_start[i] + 1 + zero_end[i - 1] - l + 1; - local_ans = local_ans.max(pz); - } - } - if j < zero_end.len() && j > 0 { - if r >= zero_start[j] { - let pz = zero_end[j - 1] - zero_start[j - 1] + 1 + r - zero_start[j] + 1; - local_ans = local_ans.max(pz); - } + if cur_arr[cur_st] * 10 + s[cur] <= 255 && cur_arr[cur_st] != 0 { + cur_arr[cur_st] = cur_arr[cur_st] * 10 + s[cur]; + let mut arr = Self::dfs(s, cur + 1, cur_arr, cur_st); + if cur_st < 3 { + cur_arr[cur_st] /= 10; + cur_arr[cur_st + 1] = s[cur]; + for t in Self::dfs(s,cur + 1, cur_arr, cur_st + 1) { + arr.push(t); } } - if i == j { - if i > 0 - && i < zero_len.len() - && j < zero_len.len() - && j > 0 - && zero_end[i - 1] >= l - && zero_start[i] <= r - { - let pz = zero_end[j - 1] - l + 1 + r - zero_start[j] + 1; - local_ans = local_ans.max(pz); - } - } - ans.push((local_ans + one) as i32); + return arr; } - ans + if cur_st < 3{ + cur_arr[cur_st + 1] = s[cur]; + return Self::dfs(s, cur + 1, cur_arr, cur_st + 1); + } + vec![] } } fn main() { println!( "{:?}", - Solution::max_active_sections_after_trade( - "0110110101010000101".to_string(), - make_matrix("[[12,17]]") - ) + Solution::restore_ip_addresses("0000".to_string()) ); }