İki dizi verildiğinde; $birthsbirinin doğduğunu gösteren doğum yıllarının $deathslistesini ve birinin öldüğünü gösteren ölüm yıllarının listesini içeren, nüfusun en yüksek olduğu yılı nasıl bulabiliriz?

Örneğin, aşağıdaki diziler verildiğinde:

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

Nüfusun en yüksek olduğu yıl olmalıdır 1996, çünkü 3insanlar o yıl boyunca yaşıyorlardı, ki bu o yılların en yüksek nüfus sayısıydı.

İşte çalışan matematik:

| Doğum | Ölüm | Nüfus |
| ------- | ------- | ------------ |
| 1981 | | 1 |
| 1984 | | 2 |
| 1984 | 1984 | 2 |
| 1991 | 1991 | 2 |
| 1996 | | 3 |

Varsayımlar

Birinin doğduğu yılın nüfusu bir artabileceğini ve birisinin öldüğü yılın nüfusu bir azaltabileceğini rahatlıkla söyleyebiliriz. Bu örnekte, 1984'te 2 kişi doğdu ve 1984'te 1 kişi öldü, yani nüfus o yıl 1 oranında arttı.

Ayrıca, ölüm sayısının asla doğum sayısını geçmeyeceğini ve nüfus 0 olduğunda ölüm meydana gelemeyeceğini rahatlıkla söyleyebiliriz.

Ayrıca, her ikisindeki yılların $deathsve $birthsasla negatif veya kayan nokta değerleri olmayacağını varsayabiliriz ( her zaman 0'dan büyük pozitif tamsayılardır ).

Biz olamaz diziler sıralanmış olacak ya Ancak çift değer olmayacağını varsayıyorum.

Gereksinimler

Girdi olarak bu iki dizi göz önüne alındığında, en yüksek nüfusun meydana geldiği yılı döndürmek için bir işlev yazmalıyız. İşlev döndürebilir 0, false, ""ya da NULL( bir Falsey değer kabul edilebilir ) giriş dizileri boş ise ya da nüfus boyunca 0 ° C'de her zaman ise. En yüksek nüfus birden çok yılda meydana gelirse, işlev en yüksek nüfusa ulaşılan ilk yılı veya daha sonraki bir yılı döndürebilir.

Örneğin:

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

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

Ek olarak, çözümün Big O'su dahil olmak da yardımcı olacaktır.

Bunu yapmak için en iyi girişimim şöyle olurdu:

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;
}

Algoritma yukarıdaki o en kötü olduğu Verilen polinom zamanda çalışması gerekir O(((n log n) * 2) + k)nerede nunsurların sayısı her diziden sıralanıp edilecek olan k(doğum yıl sayısıdır bunu biliyoruz çünkü kher zamank >= y olduğu) yölüm yıl sayısıdır. Ancak, daha verimli bir çözüm olup olmadığından emin değilim.

İlgi alanlarım , mevcut algoritma üzerinde gelişmiş bir hesaplama karmaşıklığı Big O'sunda. Bellek karmaşıklığı endişe vermez. Çalışma zamanı optimizasyonu da değildir. En azından birincil bir endişe değil . Herhangi bir küçük / büyük çalışma zamanı optimizasyonu açıktır, ancak burada anahtar faktör değildir.

Bence ilk olarak sınıflandırarak, daha sonra yinelediğimizde mevcut nüfusu ve küresel maksimumu koruyarak ek alanla O(n log n)zaman geçirebiliriz O(1). Mevcut yılı referans noktası olarak kullanmaya çalıştım, ancak mantık hala biraz zor görünüyordu, bu yüzden tamamen çalıştığından emin değilim. Umarım, yaklaşım hakkında bir fikir verebilir.

JavaScript kodu (karşı örnek / hata kabul edilir)

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));

Yıl aralığı,, msırasına göre ise n, her yıl için sayıları aralıkta saklayabilir ve O(n)zaman karmaşıklığına sahip olabiliriz. Eğer süslenmek istiyorsak, O(n * log log m)zaman içinde ardıl aramaya izin veren Y-hızlı bir üçlü kullanarak zaman karmaşıklığına da sahip olabiliriz O(log log m).

Bunu lineer zamanda kova sıralamasıyla çözebiliriz. Diyelim ki girdinin boyutu n, yıl aralığı 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.

En büyük kümülatif maksimum cevaptır.

Çalışma süresi O (n + m) ve ihtiyaç duyulan ek alan O (m) 'dir.

M, O (n) ise, bu n'deki doğrusal bir çözeltidir; örneğin, yıl aralığı doğum ve ölüm sayısından daha hızlı büyümiyorsa. Bu gerçek dünya verileri için neredeyse kesinlikle doğrudur.

Önce doğumları ve ölümleri bir haritaya ( year => population change) toplayın, bunu anahtarla sıralayın ve çalışan nüfusu hesaplayın.

Bu yaklaşık olarak O(2n + n log n), ndoğum sayısı nerede olmalıdır .

$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));

Bu sorunu O(n+m)[en kötü durumda, en iyi durumda O(n)] bellek gereksinimi ile çözdüm

ve zaman karmaşıklığı O(n logn).

İşte, n & muzunluğu birthsve deathsdizileri.

PHP veya javascript bilmiyorum. Java ile uyguladım ve mantık çok basit. Ancak fikrimin bu dillerde de uygulanabileceğine inanıyorum.

Teknik Detaylar:

Java TreeMapyapısını doğum ve ölüm kayıtlarını saklamak için kullandım .

TreeMap(anahtar, değer) çifti olarak sıralanan ( anahtar tabanlı ) verileri ekler , burada anahtar yıl ve değer doğumların ve ölümlerin (ölümler için negatif) kümülatif toplamıdır.

Biz gerek yok sonra olanları ölümler değeri eklemek için en yüksek doğum yılı.

TreeMap doğum ve ölüm kayıtları ile doldurulduktan sonra, tüm kümülatif toplamlar güncellenir ve ilerledikçe maksimum nüfusu yılla birlikte depolar.

Örnek giriş ve çıkış: 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

Örnek giriş ve çıkış: 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

Burada, 1914 & laterson doğum yılından sonra meydana gelen ölümler ( ) 1913sayılmazdı, bu da gereksiz hesaplamalardan kaçınır.

Toplam 10 millionveri (doğumlar ve ölümler birleşti) ve daha fazlası için 1000 years range, program 3 sec.bitmek üzereydi .

Aynı büyüklükte verilerle 100 years range, aldı 1.3 sec.

Tüm girişler rastgele alınır.

$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);

Bu, bağlı bir yılın olasılığını ve bir kişinin ölümünün bir yılının doğumuna karşılık gelip gelmediğini açıklayacaktır.

Bellek akıllıca tutmak currentPopulationve currentYearhesaplamaktır. Her iki sıralayarak başlayan $birthsve $deathskabarcık sıralama ağır görev, henüz bazı köşeleri kesmek için izin verdiğini olmadığı için, diziler çok iyi bir noktadır:

<?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);

Büyük O şeye dalmaya gerçekten hevesli değil , size bıraktı.

Ayrıca, currentYearComputingher döngüyü yeniden keşfederseniz , döngüleri ififadelere dönüştürebilir ve yalnızca bir döngü ile ayrılabilirsiniz.

    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;
        }

Ben bu çözümü çok rahat dolduruyorum, karmaşıklığı Büyük 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));
?>

Sorununuz için en basit ve açık yaklaşımlardan biri.

$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);

çıktı :

1909

karmaşıklık :

O(m + log(n))