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:
File size: 4,198 Bytes
21f9b41 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn dp_inf() -> i64 {
300_000i64
}
pub open spec fn is_land_or_log(a: Seq<u8>, p: int) -> bool {
p == 0 || p == a.len() + 1 || (1 <= p && p <= a.len() && a[p - 1] == 2u8)
}
pub open spec fn is_water(a: Seq<u8>, p: int) -> bool {
1 <= p && p <= a.len() && a[p - 1] == 0u8
}
pub open spec fn is_croc(a: Seq<u8>, p: int) -> bool {
1 <= p && p <= a.len() && a[p - 1] == 1u8
}
pub open spec fn land_cost(a: Seq<u8>, p: int) -> int {
if is_water(a, p) { 1int } else { 0int }
}
pub open spec fn dp_min_pred(dp_prev: Seq<i64>, a: Seq<u8>, m: int, p: int, j_start: int, j_end: int) -> i64
recommends
dp_prev.len() == p,
0 <= j_start <= j_end <= p,
m >= 1,
decreases j_end - j_start,
{
if j_start >= j_end {
dp_inf()
} else {
let prev = dp_min_pred(dp_prev, a, m, p, j_start + 1, j_end);
let cur = dp_prev[j_start];
let valid = if cur >= dp_inf() {
false
} else if is_land_or_log(a, j_start) {
j_start + 1 <= p && p <= j_start + m
} else if is_water(a, j_start) {
p == j_start + 1
} else {
false
};
if valid {
let cand = (cur as int + land_cost(a, p)) as i64;
if cand < prev { cand } else { prev }
} else {
prev
}
}
}
pub open spec fn dp_at(dp_prev: Seq<i64>, a: Seq<u8>, m: int, p: int) -> i64
recommends
dp_prev.len() == p,
0 <= p <= a.len() + 1,
m >= 1,
{
if p == 0 {
0i64
} else if is_croc(a, p) {
dp_inf()
} else {
let lo = if p > m { p - m } else { 0int };
dp_min_pred(dp_prev, a, m, p, lo, p)
}
}
pub open spec fn compute_dp_upto(a: Seq<u8>, m: int, k_max: int) -> Seq<i64>
recommends
0 <= k_max <= a.len() + 1,
m >= 1,
decreases k_max,
{
if k_max <= 0 {
seq![0i64]
} else {
let prev = compute_dp_upto(a, m, k_max - 1);
prev.push(dp_at(prev, a, m, k_max))
}
}
pub open spec fn compute_dp(a: Seq<u8>, m: int) -> Seq<i64>
recommends
m >= 1,
{
compute_dp_upto(a, m, a.len() as int + 1)
}
impl Solution {
pub fn can_cross(a: Vec<u8>, m: usize, k: i64) -> (result: bool)
requires
1 <= a.len() <= 200_000,
1 <= m <= 10,
0 <= k <= 200_000,
forall|i: int| 0 <= i < a.len() ==> #[trigger] a[i] <= 2,
ensures
({
let dp = compute_dp(a@, m as int);
let final_dp = dp[a.len() as int + 1];
result == (final_dp < dp_inf() && final_dp <= k)
}),
{
let n = a.len();
let inf: i64 = 300_000;
let mut dp: Vec<i64> = Vec::with_capacity(n + 2);
dp.push(0);
let mut p: usize = 1;
while p <= n + 1 {
let val = if p <= n && a[p - 1] == 1 {
inf
} else {
let lo: usize = if p > m { p - m } else { 0 };
let mut best = inf;
let mut jj: usize = p;
while jj > lo {
jj = jj - 1;
let djv = dp[jj];
if djv < inf {
let valid = if jj == 0 || jj == n + 1 || (1 <= jj && jj <= n && a[jj - 1] == 2) {
jj + 1 <= p && p <= jj + m
} else if 1 <= jj && jj <= n && a[jj - 1] == 0 {
p == jj + 1
} else {
false
};
if valid {
let cost: i64 = if p >= 1 && p <= n && a[p - 1] == 0 { 1 } else { 0 };
let cand = djv + cost;
if cand < best {
best = cand;
}
}
}
}
best
};
dp.push(val);
p = p + 1;
}
dp[n + 1] < inf && dp[n + 1] <= k
}
}
}
|