程序员面试金典 16.10

Living People：给定一些人的出生年份和死亡年份，计算哪一年活着的人数最多，相同情况下输出年份最小的，假设年份都在[1900, 2000]。

简单的解法就是暴力搜索，反正就100年，时间复杂度为O(RP)，其中R表示年份的区间，P表示人数。

class Solution {
public:
    int maxAliveYear(vector<int>& birth, vector<int>& death) {
        int maxLive = 0, maxYear = 1900, live;
        for(int year = 1900; year <= 2000; year++)
        {
            live = 0;
            for(size_t p = 0; p < birth.size(); p++)
            {
                if(birth[p] <= year && year <= death[p]){
                    live++;
                }
            }
            if(live > maxLive){
                maxLive = live;
                maxYear = year;
            }
        }
        return maxYear;
    }
};

一种可能更快的暴力搜索就是为年份建立一个数组，用来记录这一年活着的人数，然后遍历每一个人，根据他的生卒年份更新数组。这种解法相对于前面的解法会少几次循环，复杂度为O(PY + R)，Y是活的最久的人的年龄，最坏情况就是R。

class Solution {
private:
    vector<int> vecLive;
    int year2idx(const int year)
    {
        return year - 1900;
    }
    int idx2year(const int idx)
    {
        return idx + 1900;
    }
public:
    int maxAliveYear(vector<int>& birth, vector<int>& death) {
        vecLive.assign(2000 - 1900 + 1, 0);
        for(size_t p = 0; p < birth.size(); p++)
        {
            for(int year = birth[p]; year<= death[p]; year++)
            {
                vecLive[year2idx(year)]++;
            }
        }
        int maxLive = 0, maxYear;
        for(size_t idx = 0; idx < vecLive.size(); idx++)
        {
            if(vecLive[idx] > maxLive){
                maxLive = vecLive[idx];
                maxYear = idx2year(idx);
            }
        }
        return maxYear;
    }
};

如果手算，那我会从最小的一年开始，依次考察每一年，当这一年有人出生时，活着的人数就增加，同时更新活着人数最多的年份；当这一点有人死亡时，活着的人数就减少。根据这个思路，先对输入数据进行排序，最后进行归并排序，终止条件是birth数组结束，时间复杂度为O(PlogP)。

class Solution {
public:
    int maxAliveYear(vector<int>& birth, vector<int>& death) {
        sort(birth.begin(), birth.end());
        sort(death.begin(), death.end());
        size_t birthIdx = 0, deathIdx = 0;
        int currLive = 0, maxLive = 0, maxYear;
        while(birthIdx != birth.size()){
            if(birth[birthIdx] <= death[deathIdx]){
                currLive++;
                if(currLive > maxLive){
                    maxLive = currLive;
                    maxYear = birth[birthIdx];
                }
                birthIdx++;
            }
            else{
                currLive--;
                deathIdx++;
            }
        }
        return maxYear;
    }
};

也可以不对输入数据进行排序，统计一下每一年人数的变化情况vecDelta，通过计算数组和，返回得到最大值时候的最小年份。这里要注意如果这一年同时有人出生和死亡，根据题意，出生人数要算在这一年，死亡人数算到下一年。

class Solution {
private:
    int year2idx(const int year)
    {
        return year - 1900;
    }
    int idx2year(const int idx)
    {
        return idx + 1900;
    }
public:
    int maxAliveYear(vector<int>& birth, vector<int>& death) {
        vector<int> vecDelta(2000 - 1900 + 2, 0);
        for(size_t idx = 0; idx < birth.size(); idx++)
        {
            vecDelta[year2idx(birth[idx])]++;
            vecDelta[year2idx(death[idx]) + 1]--;
        }
        int currLive = 0, maxLive = 0, maxYear;
        for(size_t idx = 0; idx < vecDelta.size(); idx++)
        {
            currLive += vecDelta[idx];
            if(currLive > maxLive){
                maxLive = currLive;
                maxYear = idx2year(idx);
            }
        }
        return maxYear;
    }
};