Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
competitive-programming
code-generation
specification-generation
proof-generation
verification
rust
License:
| use vstd::prelude::*; | |
| fn main() {} | |
| verus! { | |
| pub struct Solution; | |
| pub open spec fn valid_coloring(houses: Seq<i32>, colors: Seq<int>, n: int) -> bool { | |
| houses.len() == colors.len() && | |
| forall|i: int| 0 <= i < houses.len() as int ==> ( | |
| 1 <= colors[i] <= n && | |
| (houses[i] != 0 ==> colors[i] == houses[i] as int) | |
| ) | |
| } | |
| pub open spec fn count_neighborhoods(colors: Seq<int>) -> int | |
| decreases colors.len(), | |
| { | |
| if colors.len() <= 0 { | |
| 0 | |
| } else if colors.len() == 1 { | |
| 1 | |
| } else { | |
| count_neighborhoods(colors.drop_last()) + | |
| if colors.last() != colors[colors.len() - 2] { 1int } else { 0int } | |
| } | |
| } | |
| pub open spec fn total_paint_cost( | |
| houses: Seq<i32>, | |
| cost: Seq<Vec<i32>>, | |
| colors: Seq<int>, | |
| len: int, | |
| ) -> int | |
| decreases len, | |
| { | |
| if len <= 0 { | |
| 0int | |
| } else { | |
| total_paint_cost(houses, cost, colors, len - 1) + | |
| if houses[len - 1] != 0i32 { 0int } else { cost[len - 1]@[colors[len - 1] - 1] as int } | |
| } | |
| } | |
| pub open spec fn spec_min(a: int, b: int) -> int { | |
| if a <= b { a } else { b } | |
| } | |
| pub open spec fn dp_spec( | |
| houses: Seq<i32>, | |
| cost: Seq<Vec<i32>>, | |
| n: int, | |
| i: int, | |
| j: int, | |
| k: int, | |
| ) -> int | |
| decreases i, 0int, | |
| { | |
| if j < 1 || j > n || k < 1 || k > i + 1 { | |
| 1_000_001int | |
| } else if i == 0 { | |
| if k != 1 { | |
| 1_000_001int | |
| } else if houses[0] as int != 0 && houses[0] as int != j { | |
| 1_000_001int | |
| } else if houses[0] as int != 0 { | |
| 0int | |
| } else { | |
| cost[0]@[j - 1] as int | |
| } | |
| } else if houses[i] as int != 0 && houses[i] as int != j { | |
| 1_000_001int | |
| } else { | |
| let paint_cost: int = if houses[i] as int != 0 { | |
| 0int | |
| } else { | |
| cost[i]@[j - 1] as int | |
| }; | |
| let same = dp_spec(houses, cost, n, i - 1, j, k); | |
| let diff = min_excluding(houses, cost, n, i - 1, j, k - 1, 1); | |
| let best = spec_min(same, diff); | |
| if best >= 1_000_001int || paint_cost + best >= 1_000_001int { | |
| 1_000_001int | |
| } else { | |
| paint_cost + best | |
| } | |
| } | |
| } | |
| pub open spec fn min_excluding( | |
| houses: Seq<i32>, | |
| cost: Seq<Vec<i32>>, | |
| n: int, | |
| i: int, | |
| exclude: int, | |
| k: int, | |
| from_c: int, | |
| ) -> int | |
| decreases i, n - from_c + 1, | |
| { | |
| if from_c > n { | |
| 1_000_001int | |
| } else if from_c == exclude { | |
| min_excluding(houses, cost, n, i, exclude, k, from_c + 1) | |
| } else { | |
| spec_min( | |
| dp_spec(houses, cost, n, i, from_c, k), | |
| min_excluding(houses, cost, n, i, exclude, k, from_c + 1), | |
| ) | |
| } | |
| } | |
| pub open spec fn min_final( | |
| houses: Seq<i32>, | |
| cost: Seq<Vec<i32>>, | |
| n: int, | |
| m: int, | |
| target: int, | |
| from_c: int, | |
| ) -> int | |
| decreases n - from_c + 1, | |
| { | |
| if from_c > n { | |
| 1_000_001int | |
| } else { | |
| spec_min( | |
| dp_spec(houses, cost, n, m - 1, from_c, target), | |
| min_final(houses, cost, n, m, target, from_c + 1), | |
| ) | |
| } | |
| } | |
| pub open spec fn answer_spec( | |
| houses: Seq<i32>, | |
| cost: Seq<Vec<i32>>, | |
| n: int, | |
| m: int, | |
| target: int, | |
| ) -> int { | |
| let min_val = min_final(houses, cost, n, m, target, 1); | |
| if min_val >= 1_000_001int { | |
| -1int | |
| } else { | |
| min_val | |
| } | |
| } | |
| impl Solution { | |
| pub fn min_cost( | |
| houses: Vec<i32>, | |
| cost: Vec<Vec<i32>>, | |
| m: i32, | |
| n: i32, | |
| target: i32, | |
| ) -> (result: i32) | |
| requires | |
| m as int == houses@.len(), | |
| m as int == cost@.len(), | |
| 1 <= m <= 100, | |
| 1 <= n <= 20, | |
| 1 <= target <= m, | |
| forall|i: int| 0 <= i < m as int ==> 0 <= houses@[i] <= n, | |
| forall|i: int| | |
| 0 <= i < m as int ==> ( cost@[i])@.len() == n as int, | |
| forall|i: int, j: int| | |
| 0 <= i < m as int && 0 <= j < n as int ==> 1 <= cost@[i]@[j] | |
| <= 10_000, | |
| ensures | |
| result as int == answer_spec(houses@, cost@, n as int, m as int, target as int), | |
| { | |
| let m_us = m as usize; | |
| let n_us = n as usize; | |
| let target_us = target as usize; | |
| let stride: usize = target_us + 1; | |
| let dp_size: usize = (n_us + 1) * stride; | |
| let mut prev_dp: Vec<i32> = Vec::new(); | |
| let mut idx: usize = 0; | |
| while idx < dp_size { | |
| prev_dp.push(1_000_001i32); | |
| idx += 1; | |
| } | |
| let mut j: usize = 1; | |
| while j <= n_us { | |
| if houses[0] != 0 { | |
| if houses[0] as usize == j { | |
| prev_dp.set(j * stride + 1, 0i32); | |
| } | |
| } else { | |
| prev_dp.set(j * stride + 1, cost[0][j - 1]); | |
| } | |
| j += 1; | |
| } | |
| let mut i: usize = 1; | |
| while i < m_us { | |
| let mut curr_dp: Vec<i32> = Vec::new(); | |
| let mut idx: usize = 0; | |
| while idx < dp_size { | |
| curr_dp.push(1_000_001i32); | |
| idx += 1; | |
| } | |
| let mut j: usize = 1; | |
| while j <= n_us { | |
| if houses[i] == 0 || houses[i] as usize == j { | |
| let paint_cost: i32 = | |
| if houses[i] != 0 { 0i32 } else { cost[i][j - 1] }; | |
| let mut k: usize = 1; | |
| while k <= target_us { | |
| let same: i32 = prev_dp[j * stride + k]; | |
| let mut diff: i32 = 1_000_001i32; | |
| let mut c: usize = 1; | |
| while c <= n_us { | |
| if c != j { | |
| let val: i32 = prev_dp[c * stride + (k - 1)]; | |
| if val < diff { | |
| diff = val; | |
| } | |
| } | |
| c += 1; | |
| } | |
| let best: i32 = if same <= diff { same } else { diff }; | |
| if best < 1_000_001i32 { | |
| let total: i32 = paint_cost + best; | |
| if total < 1_000_001i32 { | |
| curr_dp.set(j * stride + k, total); | |
| } | |
| } | |
| k += 1; | |
| } | |
| } | |
| j += 1; | |
| } | |
| prev_dp = curr_dp; | |
| i += 1; | |
| } | |
| let mut ans: i32 = 1_000_001i32; | |
| let mut j: usize = 1; | |
| while j <= n_us { | |
| let val: i32 = prev_dp[j * stride + target_us]; | |
| if val < ans { | |
| ans = val; | |
| } | |
| j += 1; | |
| } | |
| if ans >= 1_000_001i32 { -1i32 } else { ans } | |
| } | |
| } | |
| } | |