두 개의 배열이 주어진다; $births누군가가 태어 났을 때를 나타내는 생년월일 $deaths목록과 누군가가 죽었을 때를 나타내는 사망 년 목록이 들어있는 경우, 인구가 가장 높은 해를 어떻게 찾을 수 있습니까?

예를 들어 다음과 같은 배열이 있습니다.

$births = [1984, 1981, 1984, 1991, 1996];
$deaths = [1991, 1984];

그 해에 사람들이 살아 1996있었기 때문에 인구가 가장 높은 연도는이어야합니다 . 이는 3그 기간 동안 가장 많은 인구 수였습니다.

여기에 실행중인 수학이 있습니다.

| 출생 | 죽음 | 인구 |
| ------- | ------- | ------------ |
| 1981 | | 1 |
| 1984 | | 2 |
| 1984 | 1984 | 2 |
| 1991 | 1991 | 2 |
| 1996 | | 3 |

가정

우리는 누군가가 태어난 해가 1 년 증가 할 수 있고 누군가가 사망 한 해가 1 감소 할 수 있다고 안전하게 가정 할 수 있습니다. 이 예에서 1984 년에 2 명이 태어 났고 1984 년에 1 명이 사망했습니다. 이는 그해 인구가 1 명 증가했음을 의미합니다.

또한 사망자 수가 절대로 출생자 수를 초과하지 않으며 모집단이 0 일 때 사망 할 수 없다고 안전하게 추측 할 수 있습니다.

우리는 또한 안전하게 모두 년간 있다고 가정 할 수 있습니다 $deaths및 $births(음수 또는 부동 소수점 값 없을 것 그들은 항상 0보다 큰 양의 정수이야 ).

우리는 할 수없는 배열 정렬됩니다 또는 그러나, 중복 값이 없을 것으로 가정합니다.

요구 사항

이 두 배열을 입력으로하여 가장 많은 인구가 발생한 연도를 반환하는 함수를 작성해야합니다. 이 함수는 반환 할 수 있습니다 0, false, "", 또는 NULL( 어떤 falsey 값이 허용 ) 입력 배열이 비어있는 경우 또는 인구가 전체에서 0 항상 있다면. 최고 인구가 여러 해에 발생한 경우이 함수는 최고 인구에 도달 한 첫 해 또는 그 다음 해를 반환 할 수 있습니다.

예를 들면 다음과 같습니다.

$births = [1997, 1997, 1997, 1998, 1999];
$deaths = [1998, 1999];

/* The highest population was 3 on 1997, 1998 and 1999, either answer is correct */

또한 솔루션 의 Big O 를 포함하면 도움이됩니다.

이 작업을 수행하기위한 최선의 시도는 다음과 같습니다.

function highestPopulationYear(Array $births, Array $deaths): Int {

    sort($births);
    sort($deaths);

    $nextBirthYear = reset($births);
    $nextDeathYear = reset($deaths);

    $years = [];
    if ($nextBirthYear) {
        $years[] = $nextBirthYear;
    }
    if ($nextDeathYear) {
        $years[] = $nextDeathYear;
    }

    if ($years) {
        $currentYear = max(0, ...$years);
    } else {
        $currentYear = 0;
    }

    $maxYear = $maxPopulation = $currentPopulation = 0;

    while(current($births) !== false || current($deaths) !== false || $years) {

        while($currentYear === $nextBirthYear) {
            $currentPopulation++;
            $nextBirthYear = next($births);
        }

        while($currentYear === $nextDeathYear) {
            $currentPopulation--;
            $nextDeathYear = next($deaths);
        }

        if ($currentPopulation >= $maxPopulation) {
            $maxPopulation = $currentPopulation;
            $maxYear = $currentYear;
        }

        $years = [];

        if ($nextBirthYear) {
            $years[] = $nextBirthYear;
        }
        if ($nextDeathYear) {
            $years[] = $nextDeathYear;
        }
        if ($years) {
            $currentYear = min($years);
        } else {
            $currentYear = 0;
        }
    }

    return $maxYear;
}

위의 알고리즘 은 각 배열에서 정렬 할 요소의 수가 많은 최악의 O(((n log n) * 2) + k)경우 n와 죽음의 년이 있는 k출생 연도 ( 항상 우리가 알고 있기 때문에) 인kk >= y 다항식 시간에서 작동해야합니다 y. 그러나 더 효율적인 솔루션이 있는지 확실하지 않습니다.

내 관심은 순전히 기존 알고리즘에 대한 계산 복잡성 의 개선 된 Big O에 있습니다. 메모리 복잡도는 중요하지 않습니다. 런타임 최적화도 아닙니다. 적어도 그것은 주요 관심사가 아닙니다 . 사소한 / 주요 런타임 최적화는 환영하지만 여기서 중요한 요소는 아닙니다.

나는 우리가 가질 수있는 생각 O(n log n)과 시간이 O(1)우리 반복 처리로 현재 인구와 세계 최대를 유지, 첫 번째 정렬하여 추가 공간을. 나는 현재 연도를 기준점으로 사용하려고했지만 논리가 여전히 까다로워서 완전히 해결되지는 않았습니다. 바라건대, 접근 방식에 대한 아이디어를 줄 수 있습니다.

JavaScript 코드 (카운터 예 / 버그 환영)

function f(births, deaths){
  births.sort((a, b) => a - b);
  deaths.sort((a, b) => a - b);

  console.log(JSON.stringify(births));
  console.log(JSON.stringify(deaths));
  
  let i = 0;
  let j = 0;
  let year = births[i];
  let curr = 0;
  let max = curr;

  while (deaths[j] < births[0])
    j++;

  while (i < births.length || j < deaths.length){
    while (year == births[i]){
      curr = curr + 1;
      i = i + 1;
    }
    
    if (j == deaths.length || year < deaths[j]){
      max = Math.max(max, curr);
      console.log(`year: ${ year }, max: ${ max }, curr: ${ curr }`);
    
    } else if (j < deaths.length && deaths[j] == year){
      while (deaths[j] == year){
        curr = curr - 1;
        j = j + 1;
      }
      max = Math.max(max, curr);
      console.log(`year: ${ year }, max: ${ max }, curr: ${ curr }`);
    }

    if (j < deaths.length && deaths[j] > year && (i == births.length || deaths[j] < births[i])){
      year = deaths[j];
      while (deaths[j] == year){
        curr = curr - 1;
        j = j + 1;
      }
      console.log(`year: ${ year }, max: ${ max }, curr: ${ curr }`);
    }

    year = births[i];
  }
  
  return max;
}

var input = [
  [[1997, 1997, 1997, 1998, 1999],
  [1998, 1999]],
  [[1, 2, 2, 3, 4],
  [1, 2, 2, 5]],
  [[1984, 1981, 1984, 1991, 1996],
  [1991, 1984, 1997]],
  [[1984, 1981, 1984, 1991, 1996],
  [1991, 1982, 1984, 1997]]
]

for (let [births, deaths] of input)
  console.log(f(births, deaths));

연도 범위 m가 ~에 해당하면 n각 연도의 수를 범위에 저장하고 O(n)시간을 복잡하게 할 수 있습니다. 우리가 화려하고 싶다면 O(n * log log m), 후속 조회를 가능 하게 하는 Y- 고속 트라이 를 사용하여 시간 복잡성을 가질 수도 있습니다 O(log log m).

버킷 정렬로 선형 시간으로 이것을 해결할 수 있습니다. 입력 크기가 n이고 연도 범위가 m이라고 가정 해 봅시다.

O(n): Find the min and max year across births and deaths.
O(m): Create an array of size max_yr - min_yr + 1, ints initialized to zero. 
      Treat the first cell of the array as min_yr, the next as min_yr+1, etc...
O(n): Parse the births array, incrementing the appropriate index of the array. 
      arr[birth_yr - min_yr] += 1
O(n): Ditto for deaths, decrementing the appropriate index of the array.
      arr[death_yr - min_yr] -= 1
O(m): Parse your array, keeping track of the cumulative sum and its max value.

가장 큰 누적 최대 값이 답입니다.

실행 시간은 O (n + m)이며 필요한 추가 공간은 O (m)입니다.

m이 O (n) 인 경우 n의 선형 솔루션입니다. 즉, 연령 범위가 출생 및 사망자 수보다 빠르게 성장하지 않는 경우. 이것은 실제 데이터에 거의 해당됩니다.

먼저 출생과 사망을지도 ( year => population change)로 모으고 키별로 정렬 한 다음 해당 인구를 계산합니다.

대략적인 O(2n + n log n)위치 여야합니다 n. 출생 수는 어디 입니까?

$births = [1984, 1981, 1984, 1991, 1996];
$deaths = [1991, 1984];

function highestPopulationYear(array $births, array $deaths): ?int
{
    $indexed = [];

    foreach ($births as $birth) {
        $indexed[$birth] = ($indexed[$birth] ?? 0) + 1;
    }

    foreach ($deaths as $death) {
        $indexed[$death] = ($indexed[$death] ?? 0) - 1;
    }

    ksort($indexed);

    $maxYear = null;
    $max = $current = 0;

    foreach ($indexed as $year => $change) {
        $current += $change;
        if ($current >= $max) {
            $max = $current;
            $maxYear = $year;
        }
    }

    return $maxYear;
}

var_dump(highestPopulationYear($births, $deaths));

O(n+m)[최악의 경우 가장 좋은 경우 O(n)] 의 메모리 요구 사항으로이 문제를 해결했습니다 .

및의 시간 복잡성 O(n logn).

여기에 n & m길이 births와 deaths배열이 있습니다.

PHP 나 자바 스크립트를 모른다. Java로 구현 했으며 논리가 매우 간단합니다. 그러나 나는 그 아이디어를 그 언어로도 구현할 수 있다고 생각합니다.

기술 세부 사항 :

TreeMap출생 및 사망 기록을 저장하기 위해 Java 구조를 사용했습니다 .

TreeMap(키, 값) 쌍으로 정렬 된 ( 키 기반 ) 데이터를 삽입합니다 . 여기에서 키는 연도 이고 값은 출생 및 사망의 누적 합계입니다 (사망의 경우 음수).

우리는 필요하지 않습니다 애프터 일어난 사망 값 삽입 가장 높은 출생 연도를.

TreeMap에 출생 및 사망 기록이 채워지면 모든 누적 합계가 업데이트되고 진행률에 따라 최대 인구를 연도별로 저장합니다.

샘플 입력 및 출력 : 1

Births: [1909, 1919, 1904, 1911, 1908, 1908, 1903, 1901, 1914, 1911, 1900, 1919, 1900, 1908, 1906]

Deaths: [1910, 1911, 1912, 1911, 1914, 1914, 1913, 1915, 1914, 1915]

Year counts Births: {1900=2, 1901=1, 1903=1, 1904=1, 1906=1, 1908=3, 1909=1, 1911=2, 1914=1, 1919=2}

Year counts Birth-Deaths combined: {1900=2, 1901=1, 1903=1, 1904=1, 1906=1, 1908=3, 1909=1, 1910=-1, 1911=0, 1912=-1, 1913=-1, 1914=-2, 1915=-2, 1919=2}

Yearwise population: {1900=2, 1901=3, 1903=4, 1904=5, 1906=6, 1908=9, 1909=10, 1910=9, 1911=9, 1912=8, 1913=7, 1914=5, 1915=3, 1919=5}

maxPopulation: 10
yearOfMaxPopulation: 1909

샘플 입력 및 출력 : 2

Births: [1906, 1901, 1911, 1902, 1905, 1911, 1902, 1905, 1910, 1912, 1900, 1900, 1904, 1913, 1904]

Deaths: [1917, 1908, 1918, 1915, 1907, 1907, 1917, 1917, 1912, 1913, 1905, 1914]

Year counts Births: {1900=2, 1901=1, 1902=2, 1904=2, 1905=2, 1906=1, 1910=1, 1911=2, 1912=1, 1913=1}

Year counts Birth-Deaths combined: {1900=2, 1901=1, 1902=2, 1904=2, 1905=1, 1906=1, 1907=-2, 1908=-1, 1910=1, 1911=2, 1912=0, 1913=0}

Yearwise population: {1900=2, 1901=3, 1902=5, 1904=7, 1905=8, 1906=9, 1907=7, 1908=6, 1910=7, 1911=9, 1912=9, 1913=9}

maxPopulation: 9
yearOfMaxPopulation: 1906

여기 1914 & later에서 마지막 생년이 지난 후에 사망 ( )이 발생 하여 1913전혀 계산되지 않아 불필요한 계산을 피할 수있었습니다.

총 10 million데이터 (출생과 사망이 합쳐진)와 그 이상 1000 years range을 위해 프로그램이 3 sec.끝나기 시작했습니다.

와 동일한 크기의 데이터가 100 years range있으면을 가져 왔습니다 1.3 sec.

모든 입력이 무작위로 취해집니다.

$births = [1984, 1981, 1984, 1991, 1996];
$deaths = [1991, 1984];
$years = array_unique(array_merge($births, $deaths));
sort($years);

$increaseByYear = array_count_values($births);
$decreaseByYear = array_count_values($deaths);
$populationByYear = array();

foreach ($years as $year) {
    $increase = $increaseByYear[$year] ?? 0;
    $decrease = $decreaseByYear[$year] ?? 0;
    $previousPopulationTally = end($populationByYear);
    $populationByYear[$year] = $previousPopulationTally + $increase - $decrease;
}

$maxPopulation = max($populationByYear);
$maxPopulationYears = array_keys($populationByYear, $maxPopulation);

$maxPopulationByYear = array_fill_keys($maxPopulationYears, $maxPopulation);
print_r($maxPopulationByYear);

이것은 연도의 가능성과 누군가의 사망 연도가 누군가의 출생과 일치하지 않는 경우를 설명합니다.

메모리 현명하게 유지 currentPopulation하고 currentYear계산하는 것입니다. 거품 정렬은 그렇게 큰 작업이 아니지만 일부 모서리를자를 수 있기 때문에 배열 $births과 $deaths배열을 모두 정렬하여 시작하는 것이 좋습니다.

<?php

$births = [1997, 1999, 2000];
$deaths = [2000, 2001, 2001];

function highestPopulationYear(array $births, array $deaths): Int {

    // sort takes time, but is neccesary for futher optimizations
    sort($births);
    sort($deaths);

    // first death year is a first year where population might decrase 
    // sorfar max population
    $currentYearComputing = $deaths[0];

    // year before first death has potential of having the biggest population
    $maxY = $currentYearComputing-1;

    // calculating population at the begining of the year of first death, start maxPopulation
    $population = $maxPop = count(array_splice($births, 0, array_search($deaths[0], $births)));

    // instead of every time empty checks: `while(!empty($deaths) || !empty($births))`
    // we can control a target time. It reserves a memory, but this slot is decreased
    // every iteration.
    $iterations = count($deaths) + count($births);

    while($iterations > 0) {
        while(current($births) === $currentYearComputing) {
            $population++;
            $iterations--;
            array_shift($births); // decreasing memory usage
        }

        while(current($deaths) === $currentYearComputing) {
            $population--;
            $iterations--;
            array_shift($deaths); // decreasing memory usage
        }

        if ($population > $maxPop) {
            $maxPop = $population;
            $maxY = $currentYearComputing;
        }

        // In $iterations we have a sum of birth/death events left. Assuming all 
        // are births, if this number added to currentPopulation will never exceed
        // current maxPoint, we can break the loop and save some time at cost of
        // some memory.
        if ($maxPop >= ($population+$iterations)) {
            break;
        }

        $currentYearComputing++;
    }

    return $maxY;
}

echo highestPopulationYear($births, $deaths);

Big O 에 뛰어 들지 않고 당신에게 맡겼습니다 .

또한 currentYearComputing모든 루프 를 다시 발견 하면 루프를 if명령문 으로 변경 하고 하나의 루프 만 남길 수 있습니다 .

    while($iterations > 0) {

        $changed = false;

        if(current($births) === $currentYearComputing) {
            // ...
            $changed = array_shift($births); // decreasing memory usage
        }

        if(current($deaths) === $currentYearComputing) {
            // ...
            $changed = array_shift($deaths); // decreasing memory usage
        }

        if ($changed === false) {
            $currentYearComputing++;
            continue;
        }

나는이 솔루션을 매우 편안하게 채 웁니다. 복잡함 Big O는 n + m입니다.

<?php
function getHighestPopulation($births, $deaths){
    $max = [];
    $currentMax = 0;
    $tmpArray = [];

    foreach($deaths as $key => $death){
        if(!isset($tmpArray[$death])){
            $tmpArray[$death] = 0;    
        }
        $tmpArray[$death]--;
    }
    foreach($births as $k => $birth){
        if(!isset($tmpArray[$birth])){
            $tmpArray[$birth] = 0;
        }
        $tmpArray[$birth]++;
        if($tmpArray[$birth] > $currentMax){
            $max = [$birth];
            $currentMax = $tmpArray[$birth];
        } else if ($tmpArray[$birth] == $currentMax) {
            $max[] = $birth;
        }
    }

    return [$currentMax, $max];
}

$births = [1997, 1997, 1997, 1998, 1999];
$deaths = [1998, 1999];

print_r (getHighestPopulation($births, $deaths));
?>

문제에 대한 가장 간단하고 명확한 접근 방법 중 하나입니다.

$births = [1909, 1919, 1904, 1911, 1908, 1908, 1903, 1901, 1914, 1911, 1900, 1919, 1900, 1908, 1906];
$deaths = [1910, 1911, 1912, 1911, 1914, 1914, 1913, 1915, 1914, 1915];

/* for generating 1 million records

for($i=1;$i<=1000000;$i++) {
    $births[] = rand(1900, 2020);
    $deaths[] = rand(1900, 2020);
}
*/

function highestPopulationYear(Array $births, Array $deaths): Int {
    $start_time = microtime(true); 
    $population = array_count_values($births);
    $deaths = array_count_values($deaths);

    foreach ($deaths as $year => $death) {
        $population[$year] = ($population[$year] ?? 0) - $death;
    }
    ksort($population, SORT_NUMERIC);
    $cumulativeSum = $maxPopulation = $maxYear = 0;
    foreach ($population as $year => &$number) {
        $cumulativeSum += $number;
        if($maxPopulation < $cumulativeSum) {
            $maxPopulation = $cumulativeSum;
            $maxYear = $year;
        }
    }
    print " Execution time of function = ".((microtime(true) - $start_time)*1000)." milliseconds"; 
    return $maxYear;
}

print highestPopulationYear($births, $deaths);

출력 :

1909

복잡성 :

O(m + log(n))