刷题日记：面试经典 150 题 DAY3

274. H 指数

原题链接 274. H 指数

重要的是都明白H指数到底是是个啥。注意到如果将引用数从大到小排序，则对于下标i有$引用数\ge citation[i]的论文有i+1篇$，注意到此时引用数递减而文章数量递增，所求H指数就是求一个交点。

class Solution {
public:
    int hIndex(vector<int>& citations) {
        sort(citations.begin(), citations.end(),greater<int>());
        int i;
        for(i = 0;i<citations.size() && citations[i]>=(i+1);i++);
        return i;
    }
};

其实时间复杂度为$O(N)$的算法更加符合直觉。我们创建一个新的数组count来记录，count[i]中存储引用数为i的文章有几篇，这里面重要的一步是将引用数大于等于n的篇数存储到count[n] 之中，这是因为对于本题来说，h指数不可能大于n，所以大于n篇数的分别计数就没有意义（该思想经常出现）

class Solution {
public:
    int hIndex(vector<int>& citations) {
        int n = citations.size();
        int count[n+1];
        memset(count,0,sizeof(count));
        for(int cite:citations) {
            if(cite >= n) {
                count[n]++;
            } else {
                count[cite]++;
            }
        }

        int sum = 0,i = 0;
        for(i = n; i>=0;i--) {
            sum += count[i];
            if(sum >= i) {
                break;
            }
        }
        return i;
    }
};

238. 除自身以外数组的乘积

原题链接 238. 除自身以外数组的乘积

题很简单，只需要注意到要处理0，可以分类讨论

• 不存在0，则只需要算出整体乘积，然后除以当前数字
• 存在一个0，则除了这个0外剩下位置都是0，该位置是所有其它数乘积
• 存在两个及以上0，则全是0

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int count_0 = 0;
        int len = nums.size();
        int total = 1;
        for(int num:nums) {
            if(num == 0) count_0++;
            else total*=num;
        }

        vector<int> result(len,0);
        if(count_0 >= 2) {
            return result;
        }
        if(count_0 == 1) {
            for(int i = 0;i < len;i++) {
                if(nums[i] == 0) {
                    result[i] = total;
                }
            }
            return result;
        }
        for(int i = 0;i < len;i++) {
            result[i] = total/nums[i];
        }
        return result;
    }
};

380. O(1) 时间插入、删除和获取随机元素

原题链接 380. O(1) 时间插入、删除和获取随机元素

数据结构设计题，之前没试过这类题，自己做想到要用哈希（废话），但是感觉脑子不够用，遂去狠狠的学习了【宫水三叶】数据结构运用题

class RandomizedSet {
private:
    unordered_map<int,int> hashmap;
    int nums[200010];
    int idx;
public:
    RandomizedSet() {
        srand((unsigned)time(NULL));
        idx = -1;
    }
    
    bool insert(int val) {
        if(hashmap.count(val) > 0) {
            return false;
        }
        nums[++idx]  = val;
        hashmap[val] = idx;
        return true;
    }
    
    bool remove(int val) {
        if(hashmap.count(val) == 0) {
            return false;
        }
        int tail = nums[idx];
        int rm_idx = hashmap[val];
        swap(nums[rm_idx],nums[idx]);

        hashmap.erase(val);
        if(val != tail) hashmap[tail] = rm_idx;
        idx--;
        return true;
    }
    
    int getRandom() {
        int random_i = rand() % (idx+1);
        return nums[random_i];
    }
};

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet* obj = new RandomizedSet();
 * bool param_1 = obj->insert(val);
 * bool param_2 = obj->remove(val);
 * int param_3 = obj->getRandom();
 */

结构：

• 一个定长数组用于存储元素，维护一个idx，表示在数组的[0...idx]中存储着元素
• 一个哈希表，存储键值对(val,idx)，即元素和其所在的下标

插入

• 直接向哈希表和数组的末尾插入

删除

• 对哈希表的操作：直接删除其键值对
• 对数组的操作：将要删除的量交换到最后，然后让idx减去1（经常用到），此时需要再更新哈希表。将key为原数组尾的值改成交换后的下标

134. 加油站

原题链接 134. 加油站

朴素的想法是，我只需要模拟开车的过程，并一个一个尝试哪一个加油站可以作为起点就可以。但是这个方法复杂度有$O(N^2)$
能在$O(N)$内做出来的方法基于以下重要观察：

• 如果从$i$出发能到达$j$而无法到达$j+1$，则从任何的$k\in [i,j]$出发都不可能到达$j+1$，也就是任何的$k\in [i,j]$都不可能作为起点，所以我们直接从$j+1$开始检查即可
  • 这是因为到达$k$时汽车至少有非负的汽油，一定不低于从$k$出发的汽油

所以我们能在每个元素至多被遍历两遍内获得答案

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int len = gas.size();
        int i = 0;
        while(i < len) {
            int cargas = 0;
            int cnt;
            for(cnt = 0;cnt < len;cnt++) {
                int j = (i+cnt)%len;
                cargas += gas[j]-cost[j];
                if(cargas < 0) {
                    break;
                }
            }
            if(cnt == len) {
                return i;
            } else {
                i += cnt+1;
            }
        }
        return -1;
    }
};

135. 分发糖果

原题链接 135. 分发糖果

第一遍做想到一个比较符合直觉的想法：考虑两种打分的分布，分别是：递增，递减

这样分糖果的策略很简单，就是在单调列中，这个孩子是打分第几低，我就给他几个糖果
实际打分的分布可以看作是多个递增递减列的组合

此时仅需要考虑中间那个孩子需要多少糖果即可，很简单能想到应该是max(left,right)
最后写成代码：

class Solution {
public:
    int candy(vector<int>& ratings) {
        int len = ratings.size();
        vector<int> uplift(len,0);
        vector<int> downlift(len,0);
        int cd = 0;
        for(int i = 1;i < len;i++){
            if(ratings[i]>ratings[i-1]) {
                cd++;
            } else  {
                cd = 0;
            }
            uplift[i] = cd;
        }
        cd = 0;
        for(int i = len-2;i >= 0;i--){
            if(ratings[i]>ratings[i+1]) {
                cd++;
            } else {
                cd = 0;
            }
            downlift[i] = cd;
        }
        cd = len;
        for(int i = 0;i < len;i++){
            cd += max(uplift[i],downlift[i]);
        }
        return cd;
    }
};