A company is planning to interview `2n`

people. Given the array `costs`

where `costs[i] = [aCost`

, the cost of flying the _{i}, bCost_{i}]`i`

person to city ^{th}`a`

is `aCost`

, and the cost of flying the _{i}`i`

person to city ^{th}`b`

is `bCost`

._{i}

Return *the minimum cost to fly every person to a city* such that exactly `n`

people arrive in each city.

**Example 1:**

Input:costs = [[10,20],[30,200],[400,50],[30,20]]Output:110Explanation:The first person goes to city A for a cost of 10. The second person goes to city A for a cost of 30. The third person goes to city B for a cost of 50. The fourth person goes to city B for a cost of 20. The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.

**Example 2:**

Input:costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]Output:1859

**Example 3:**

Input:costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]Output:3086

**Constraints:**

`2 * n == costs.length`

`2 <= costs.length <= 100`

`costs.length`

is even.`1 <= aCost`

_{i}, bCost_{i}<= 1000

```
struct Solution;
impl Solution {
fn two_city_sched_cost(costs: Vec<Vec<i32>>) -> i32 {
let n = costs.len();
let mut diffs: Vec<i32> = costs.iter().map(|v| v[0] - v[1]).collect();
diffs.sort_unstable();
let sum_of_b: i32 = costs.iter().map(|v| v[1]).sum();
let sum_of_diff: i32 = diffs.iter().take(n / 2).sum();
sum_of_b + sum_of_diff
}
}
#[test]
fn test() {
let costs: Vec<Vec<i32>> = vec_vec_i32![[10, 20], [30, 200], [400, 50], [30, 20]];
assert_eq!(Solution::two_city_sched_cost(costs), 110);
}
```