Algorithm 一次查找最大no的算法

问：我们得到了一个2n个整数的数组，其中每对整数分别代表恐龙的出生年份和死亡年份。我们要考虑的有效年限范围是[-100000到2005 ]。例如，如果输入为：

-80000 -79950 20 70 22 60 58 65 1950 2004

这意味着第一只恐龙的出生年份分别为-80000和-79950。同样地，第二只恐龙生活在20到70岁之间，依此类推

我们想知道在同一时期活下来的恐龙数量最多。给出上面2n个整数的数组，写一个方法来计算它

有人能提出解决办法吗

编辑尝试使用此-> 粗码

#include<stdio.h>
#include<stdlib.h>
#include <stddef.h>
static void insertion_sort(int *a, const size_t n) {
    size_t i, j;
    int value;
    for (i = 1; i < n; i++) {
        value = a[i];
        for (j = i; j > 0 && value < a[j - 1]; j--) {
            a[j] = a[j - 1];
        }
        a[j] = value;
    }
}


int  main(){
    int arr[10]={-80000,-79950,20,70,22,60,58,65,1950,2004};
    int strt[5],end[5];
    int bal[5];
     int i,j,k,l,m,length;
     l=0;
     m=0;
   for (i=0; i<10; i++){
       //printf("i = %2d arr[i] = %2d\n", i, arr[i]);
       if(i%2==0){
       strt[l]=arr[i];
       l++;
       }else{
       end[m]=arr[i];
       m++;
       }
   }
   insertion_sort(strt, sizeof strt / sizeof strt[0]);
   insertion_sort(end, sizeof end / sizeof end[0]);
   k=sizeof(end)/sizeof(int);
   for(j=0;j<5;j++){
       bal[i]=strt[i]-end[k-1];
       k--;

   }
   length=sizeof bal / sizeof bal[0];
   insertion_sort(bal, sizeof bal / sizeof bal[0]);
   printf("answer is = %2d",bal[length-1]);

}

#包括
#包括
#包括
静态空插入\u排序（int*a，常量大小\u t n）{
尺寸i，j；
int值；
对于（i=1；i0&&value对于（i=0；i创建一个名为
degoralevent
的结构，并将其存储一年—事件发生的年份和事件的类型—出生或死亡。实现您自己的比较函数，将其传递给qsort，以便根据年份进行第一次排序，而不是传递给事件（考虑死亡是否发生在出生之前或其他情况，即范围是否包含在两端）迭代给定的数组并将所有事件放入向量中。之后，对向量排序并依次处理事件。同时处理给定年份的所有事件（或根据声明只计算出生或死亡）并重新计算当前活恐龙的数量（出生增加1，死亡减少1）。始终存储最大值，这将是您的答案。希望这有意义

很抱歉，我给出了完整的解决方案，我想不出一个方法来给你一个提示，但实际上没有说出来。
把每一只恐龙的出生看作是一个开放的括号，死亡看作是一个封闭的括号。然后按日期对括号进行排序-这将给你提供每一个出生和死亡事件的时间顺序。在这之后，传递给父母sis排序并计算平衡（在“（”上递增，在“）”上递减）。跟踪最大平衡，它将是答案

更新：

 C++中的示例源
输入：恐龙数量n，然后是2n个出生和死亡日期。

输出：同时生活的最大恐龙数量
#包括
#包括
#包括
使用名称空间std；
int main（）
{
int n；
cin>>n；
向量恐龙（2*n）；//
int i；
对于（i=0；i>恐龙[2*i]。第一>>恐龙[2*i+1]。第一；
迪诺斯[2*i].second=1；//出生
恐龙[2*i+1].second=0；//死亡
}
排序（dinos.begin（），dinos.end（））；//首先按日期排序
int ans=0，余额=0；
对于（i=0；i
n=5
birthAndDeath = [-80000, -79950, 20, 70, 22, 60, 58, 65, 1950, 2004]
birth = [] #date of birth of dinos 
death = [] #date of death of dinos

currentAliveDinos=0
maxDinos=0
dateLastBornForMax=0
b = 0
d = 0

#we populate the both arrays for births and deaths
for i in range(0,2*n,2):
    birth.append(birthAndDeath[i])
    death.append(birthAndDeath[i+1])

#don't forget to sort arrays particuliary for death
death.sort()
birth.sort()
print birth
print death

while b!=5 and d!=5:#there are still unborn dino
    if birth[b] < death[d]: # a dino born
        currentAliveDinos = currentAliveDinos + 1
        b = b + 1 
    else: # a dino died
        currentAliveDinos = currentAliveDinos - 1
        d = d + 1       

    if maxDinos < currentAliveDinos:
        maxDinos = currentAliveDinos
        dateLastBornForMax=birth[b-1]

    print currentAliveDinos

print "max dinos = ", maxDinos, " and last dino born in ", dateLastBornForMax, " when max achieved"

n=5
出生与死亡=[-80000，-79950,20,70,22,60,58,651950,2004]
出生=[]#恐龙的出生日期
死亡=[]#恐龙死亡日期
currentAliveDinos=0
maxDinos=0
dateLastBornForMax=0
b=0
d=0
#我们填充出生和死亡的两个数组
对于范围（0,2*n,2）内的i：
出生。追加（出生与死亡[i]）
death.append（birthAndDeath[i+1]）
#别忘了对数组进行死亡排序
死亡排序
出生排序
打印出生
印刷死亡
而b！=5和d！=5:#还有未出生的恐龙
如果出生[死亡]：#一只恐龙出生
currentAliveDinos=currentAliveDinos+1
b=b+1
否则：#一只恐龙死了
currentAliveDinos=currentAliveDinos-1
d=d+1
如果maxDinos
#包括
#包括
#包括
使用名称空间std；
int main（）
{
无符号整数n；
cin>>n；
向量恐龙（2*n）；//
无符号整数i；
对于（i=0；i>恐龙[2*i]。第一>>恐龙[2*i+1]。第一；
迪诺斯[2*i].second=1；//出生
恐龙[2*i+1].second=0；//死亡
}
排序（dinos.begin（），dinos.end（））；//首先按日期排序
int ans=0，余额=0；
对于（i=0；ijava的示例源代码

输入：恐龙数量n，出生日期n，死亡日期n

产出：有史以来最大数量的恐龙同时存活

import java.util.Arrays;

public class Dinosaur {

   public static void main(String args[]) {
        int birthAndDeath[] = { -80000, -79950, 20, 70, 22, 60, 58, 65, 1950, 2004};
        System.out.print("Maximum number of dinosaurs that were ever alive at one time: " + new Dinosaur().findMaxdinosaur(birthAndDeath));
    }

   /**
    * Find the Maximum number of dinosaurs that were ever alive at one time.
    * @param years
    * @return maximum number of dinosaurs that were ever alive at one time.
    */
   public int findMaxdinosaur (int[] years) {
        /** For birth array */
        int birthArray[] = new int [years.length/2];

        /** For death array */
        int deathArray[] = new int [years.length/2]; 

        int birthCounter = 0, deathCounter = 0;
        int currentAliveDinos = 0;

        /** Maximum number of dinosaurs that were ever alive at one time. */
        int maxDinos = 0; 

        int position = 0;

        /** To get the birth and death values in different array */
        for(int index = 0; index < years.length; index = index + 2) {
            birthArray[position] = years[index];
            deathArray[position] = years[index + 1];
            position++;
        }       

        /** Sort the birth and death array in ascending order. */
        Arrays.sort(birthArray);
        Arrays.sort(deathArray);

        /** Calculating max number of dinosaurs that were ever alive at one time **/
        while( birthCounter != years.length/2 && deathCounter != years.length/2) {
            if(birthArray[birthCounter] < deathArray[deathCounter]) {
                currentAliveDinos++;
                birthCounter++;
            } else {
                currentAliveDinos--;
                deathCounter++;
            }
            if(maxDinos < currentAliveDinos) {
                maxDinos = currentAliveDinos;
            }
        }
        return maxDinos;
   }
}

导入java.util.array；
公共级恐龙{
公共静态void main（字符串参数[]）{
int出生与死亡[]={-80000，-79950,20,70,22,60,58,65,1950,2004}；
System.out.print（“一段时间内活着的恐龙的最大数量：“+新恐龙（）.FindMax恐龙（出生与死亡））；
}
/**
*找出在同一时间内活着的恐龙的最大数量。
*@param年
*@return一次活下来的恐龙的最大数量。
*/
公共int FindMax恐龙（int[]年）{
/**用于出生数组*/
int birthArray[]=新int[years.length/2]；
/**死亡阵法*/
int deathArray[]=新int[年长/2]；
int出生计数器=0，死亡计数器=0；
int currentAliveDinos=0；
/**最大数量o
Largest number of dinosaurs that were ever alive at one time?

import java.util.Arrays;

public class Dinosaur {

   public static void main(String args[]) {
        int birthAndDeath[] = { -80000, -79950, 20, 70, 22, 60, 58, 65, 1950, 2004};
        System.out.print("Maximum number of dinosaurs that were ever alive at one time: " + new Dinosaur().findMaxdinosaur(birthAndDeath));
    }

   /**
    * Find the Maximum number of dinosaurs that were ever alive at one time.
    * @param years
    * @return maximum number of dinosaurs that were ever alive at one time.
    */
   public int findMaxdinosaur (int[] years) {
        /** For birth array */
        int birthArray[] = new int [years.length/2];

        /** For death array */
        int deathArray[] = new int [years.length/2]; 

        int birthCounter = 0, deathCounter = 0;
        int currentAliveDinos = 0;

        /** Maximum number of dinosaurs that were ever alive at one time. */
        int maxDinos = 0; 

        int position = 0;

        /** To get the birth and death values in different array */
        for(int index = 0; index < years.length; index = index + 2) {
            birthArray[position] = years[index];
            deathArray[position] = years[index + 1];
            position++;
        }       

        /** Sort the birth and death array in ascending order. */
        Arrays.sort(birthArray);
        Arrays.sort(deathArray);

        /** Calculating max number of dinosaurs that were ever alive at one time **/
        while( birthCounter != years.length/2 && deathCounter != years.length/2) {
            if(birthArray[birthCounter] < deathArray[deathCounter]) {
                currentAliveDinos++;
                birthCounter++;
            } else {
                currentAliveDinos--;
                deathCounter++;
            }
            if(maxDinos < currentAliveDinos) {
                maxDinos = currentAliveDinos;
            }
        }
        return maxDinos;
   }
}