Subsequence of size k with the largest even sum

impl Solution {
  pub fn largest_even_sum(mut nums: Vec<i32>, k: i32) -> i64 {
    let k = k as usize;
    nums.sort_unstable_by(|a, b| b.cmp(a));

    let sum: i64 = nums[..k].iter().map(|&x| x as i64).sum();
    if sum % 2 == 0 {
      return sum;
    }

    // We need to swap one element in top-k with one outside top-k
    // to make sum even. We want to minimize the loss.
    // Swap odd_in with even_out or even_in with odd_out
    let mut min_odd_in = i64::MAX;  // smallest odd in top k
    let mut min_even_in = i64::MAX; // smallest even in top k
    let mut max_odd_out = -1i64;    // largest odd outside top k
    let mut max_even_out = -1i64;   // largest even outside top k

    for i in 0..k {
      if nums[i] % 2 == 1 {
        min_odd_in = min_odd_in.min(nums[i] as i64);
      } else {
        min_even_in = min_even_in.min(nums[i] as i64);
      }
    }
    for i in k..nums.len() {
      if nums[i] % 2 == 1 {
        max_odd_out = max_odd_out.max(nums[i] as i64);
      } else {
        max_even_out = max_even_out.max(nums[i] as i64);
      }
    }

    let mut best = -1i64;
    // swap smallest odd in top-k with largest even outside
    if min_odd_in != i64::MAX && max_even_out >= 0 {
      best = best.max(sum - min_odd_in + max_even_out);
    }
    // swap smallest even in top-k with largest odd outside
    if min_even_in != i64::MAX && max_odd_out >= 0 {
      best = best.max(sum - min_even_in + max_odd_out);
    }

    best
  }
}