You are given a 2D integer array `logs`

where each `logs[i] = [birth`

indicates the birth and death years of the _{i}, death_{i}]`i`

person.^{th}

The **population** of some year `x`

is the number of people alive during that year. The `i`

person is counted in year ^{th}`x`

's population if `x`

is in the **inclusive** range `[birth`

. Note that the person is _{i}, death_{i} - 1]**not** counted in the year that they die.

Return *the earliest year with the maximum population*.

**Example 1:**

Input:logs = [[1993,1999],[2000,2010]]Output:1993Explanation:The maximum population is 1, and 1993 is the earliest year with this population.

**Example 2:**

Input:logs = [[1950,1961],[1960,1971],[1970,1981]]Output:1960Explanation:The maximum population is 2, and it had happened in years 1960 and 1970. The earlier year between them is 1960.

**Constraints:**

`1 <= logs.length <= 100`

`1950 <= birth`

_{i}< death_{i}<= 2050

```
struct Solution;
impl Solution {
fn maximum_population(logs: Vec<Vec<i32>>) -> i32 {
let mut start = std::i32::MAX;
let mut end = 0;
for log in &logs {
let birth = log[0];
let death = log[1];
start = start.min(birth);
end = end.max(death);
}
let mut res = 0;
let mut max = 0;
for i in start..end {
let mut population = 0;
for log in &logs {
let birth = log[0];
let death = log[1];
if (birth..death).contains(&i) {
population += 1;
}
}
if max < population {
res = i;
max = population;
}
}
res
}
}
#[test]
fn test() {
let logs = vec_vec_i32![[1993, 1999], [2000, 2010]];
let res = 1993;
assert_eq!(Solution::maximum_population(logs), res);
let logs = vec_vec_i32![[1950, 1961], [1960, 1971], [1970, 1981]];
let res = 1960;
assert_eq!(Solution::maximum_population(logs), res);
}
```