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 is_all_ones_square(mat: Seq<Vec<i32>>, r: int, c: int, s: int) -> bool { | |
| &&& s >= 1 | |
| &&& r >= 0 && r + s <= mat.len() | |
| &&& c >= 0 && c + s <= mat[0int].len() | |
| &&& forall|dr: int, dc: int| | |
| 0 <= dr < s && 0 <= dc < s ==> mat[r + dr][c + dc] == 1 | |
| } | |
| pub open spec fn min3(a: int, b: int, c: int) -> int { | |
| if a <= b && a <= c { a } | |
| else if b <= c { b } | |
| else { c } | |
| } | |
| pub open spec fn dp_val(mat: Seq<Vec<i32>>, i: int, j: int) -> int | |
| decreases (if i > 0 { i } else { 0 }) + (if j > 0 { j } else { 0 }) | |
| { | |
| if i < 0 || j < 0 { 0 } | |
| else if mat[i][j] != 1 { 0 } | |
| else if i == 0 || j == 0 { 1 } | |
| else { 1 + min3(dp_val(mat, i - 1, j), dp_val(mat, i, j - 1), dp_val(mat, i - 1, j - 1)) } | |
| } | |
| pub open spec fn row_sum(mat: Seq<Vec<i32>>, i: int, j: int, n: int) -> int | |
| decreases (if j < n { n - j } else { 0 }) | |
| { | |
| if j >= n { 0 } | |
| else { dp_val(mat, i, j) + row_sum(mat, i, j + 1, n) } | |
| } | |
| pub open spec fn total_sum(mat: Seq<Vec<i32>>, i: int, m: int, n: int) -> int | |
| decreases (if i < m { m - i } else { 0 }) | |
| { | |
| if i >= m { 0 } | |
| else { row_sum(mat, i, 0, n) + total_sum(mat, i + 1, m, n) } | |
| } | |
| impl Solution { | |
| fn set_dp(dp: &mut Vec<Vec<i32>>, row: usize, col: usize, value: i32) | |
| requires | |
| row < old(dp)@.len(), | |
| col < old(dp)@[row as int].len(), | |
| ensures | |
| dp@.len() == old(dp)@.len(), | |
| forall |r: int| 0 <= r < dp@.len() ==> ( dp@[r]).len() == old(dp)@[r].len(), | |
| forall |r: int, c: int| | |
| 0 <= r < dp@.len() && 0 <= c < dp@[r].len() | |
| ==> dp@[r][c] == if r == row as int && c == col as int { value } else { old(dp)@[r][c] }, | |
| { | |
| let mut current_row = dp[row].clone(); | |
| current_row.set(col, value); | |
| dp.set(row, current_row); | |
| } | |
| pub fn count_squares(matrix: Vec<Vec<i32>>) -> (result: i32) | |
| requires | |
| 1 <= matrix.len() <= 300, | |
| forall |i: int| 0 <= i < matrix.len() ==> 1 <= ( matrix[i]).len() <= 300, | |
| forall |i: int| 0 <= i < matrix.len() ==> ( matrix[i]).len() == matrix[0].len(), | |
| forall |i: int, j: int| 0 <= i < matrix.len() && 0 <= j < matrix[0].len() | |
| ==> matrix[i][j] == 0 || matrix[i][j] == 1, | |
| ensures | |
| result as int == total_sum(matrix@, 0, matrix.len() as int, matrix[0].len() as int), | |
| { | |
| let m = matrix.len(); | |
| let n = matrix[0].len(); | |
| let mut dp: Vec<Vec<i32>> = Vec::new(); | |
| let mut i: usize = 0; | |
| while i < m { | |
| let mut row: Vec<i32> = Vec::new(); | |
| let mut j: usize = 0; | |
| while j < n { | |
| row.push(0); | |
| j = j + 1; | |
| } | |
| dp.push(row); | |
| i = i + 1; | |
| } | |
| let mut ans: i32 = 0; | |
| i = 0; | |
| while i < m { | |
| let mut j: usize = 0; | |
| while j < n { | |
| if matrix[i][j] == 1 { | |
| if i == 0 || j == 0 { | |
| Self::set_dp(&mut dp, i, j, 1); | |
| } else { | |
| let a = dp[i - 1][j]; | |
| let b = dp[i][j - 1]; | |
| let c = dp[i - 1][j - 1]; | |
| let min_val = if a <= b && a <= c { a } else if b <= c { b } else { c }; | |
| Self::set_dp(&mut dp, i, j, 1 + min_val); | |
| } | |
| } | |
| ans = ans + dp[i][j]; | |
| j = j + 1; | |
| } | |
| i = i + 1; | |
| } | |
| ans | |
| } | |
| } | |
| } | |