You are given an array `people`

where `people[i]`

is the weight of the `i`

person, and an ^{th}**infinite number of boats** where each boat can carry a maximum weight of `limit`

. Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most `limit`

.

Return *the minimum number of boats to carry every given person*.

**Example 1:**

Input:people = [1,2], limit = 3Output:1Explanation:1 boat (1, 2)

**Example 2:**

Input:people = [3,2,2,1], limit = 3Output:3Explanation:3 boats (1, 2), (2) and (3)

**Example 3:**

Input:people = [3,5,3,4], limit = 5Output:4Explanation:4 boats (3), (3), (4), (5)

**Constraints:**

`1 <= people.length <= 5 * 10`

^{4}`1 <= people[i] <= limit <= 3 * 10`

^{4}

```
struct Solution;
impl Solution {
fn num_rescue_boats(mut people: Vec<i32>, limit: i32) -> i32 {
let n = people.len();
people.sort_unstable();
people.reverse();
let mut i = 0;
let mut j = n - 1;
let mut res = 0;
while i <= j {
res += 1;
if people[i] + people[j] <= limit {
j -= 1;
}
i += 1;
}
res
}
}
#[test]
fn test() {
let people = vec![1, 2];
let limit = 3;
let res = 1;
assert_eq!(Solution::num_rescue_boats(people, limit), res);
let people = vec![3, 2, 2, 1];
let limit = 3;
let res = 3;
assert_eq!(Solution::num_rescue_boats(people, limit), res);
let people = vec![3, 5, 3, 4];
let limit = 5;
let res = 4;
assert_eq!(Solution::num_rescue_boats(people, limit), res);
}
```