leetcode contest 142

先记录前三题的题解，最后一题在规定时间内我没做出来，看discuss区貌似测试样例也有错，加上要期末考了没太多时间钻研，就先不记录了。

一、1093. Statistics from a Large Sample

这题是给你一串数据，A[i]=j表示数字i出现了j次。要你求这组数据的最小值、最大值、中位数、均值、众数。

感觉这题没什么质量（虽然我一开始题目看错了，浪费了一些时间），评价也不是很好。感觉没什么好说的。

class Solution {
public:
    vector<double> sampleStats(vector<int>& count) {
        
        int minind=-1,maxind=-1,n=count.size(),maxcnt=0,m=0;
        double mean=0,mode,median;
        for(int i=0;i<n;++i)
        {
            if(count[i])
            {
                if(minind==-1)
                    minind=i;
                maxind=i;
            }
            mean+=i*count[i];
            if(count[i]>maxcnt)
                maxcnt=count[i],mode=i;
            m+=count[i];
        }
        int a,b,j=0;
        for(int i=0;i<n;++i)
        {
            if(!count[i])
                continue;
            if(j+count[i]>m/2)
            {
                a=b=i;
                break;
            }
            else if(j+count[i]==m/2)
            {
                b=i,a==-1;
                for(int k=i+1;k<n&&a!=k;++k)
                    if(count[k])
                        a=k;
                break;
            }
            else
                j+=count[i];
        }
       
        if(m&1)
            median=b;
        else 
            median=(double(a)+double(b))/2;
        return {double(minind),double(maxind),mean/m,median,mode};
    }
};

二、1094. Car Pooling

这题是给定一辆车的最大载客数，然后给你多组数据，每一组表示有多少乘客在A点上车在B点下车，车子只能一直从起点走下去不能调头，要你判断可否将所有乘客载到各自的目的地。

由于一路上各个地点的表示范围为[0,1000]，因此我直接开一个数组记录每个出现在给出数据中的站点有多少人上车（+当前站点载客数）或者下车（-当前站点载客数）。再按从起点到终点的顺序遍历所有站点，每到一个站点判断车是否满载。

这种做法是O(n)的，比赛结束后我看了discuss区域一些大神给出的解法也是这个，O(n)的复杂度对这道题来说是最好的了。

class Solution {
public:
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        int pos[1001];
        memset(pos,0,sizeof(pos));
        for(auto trip:trips)
        {
            int num=trip[0],start=trip[1],end=trip[2];
            pos[start]+=num,pos[end]-=num;
        }
        int all=0;
        for(int i=0;i<1001;++i)
        {
            all+=pos[i];
            if(all>capacity)
                return false;
        }
        return true;
    }
};

三、1095. Find in Mountain Array

这道题需要好好看题目描述，读者还是点题目的链接看看吧。

我觉得这题比较明显，要考的就是二分查找。我的解法也就是二分查找：先用非常规的二分查找找出“山峰”，这样“山峰”两边的序列就都是单调的，就可以用常规的二分找出答案了。

比赛期间写的代码，比较长...。

/**
 * // This is the MountainArray's API interface.
 * // You should not implement it, or speculate about its implementation
 * class MountainArray {
 *   public:
 *     int get(int index);
 *     int length();
 * };
 */
class Solution {
public:
    int findInMountainArray(int target, MountainArray &mountainArr) {
        int n=mountainArr.length();
        int left=0,right=n-1;
        vector<int> record(n,-1);
        int topind=search(left,right,record,n,mountainArr),top;
        
        if(top!=-1)
            top=record[topind];
        int ans1=solve(0,topind,record,target,false,mountainArr),ans2=solve(topind+1,n-1,record,target,true,mountainArr);
        if(ans1!=-1&&ans2!=-1)
            return ans1;
        else if(ans1==-1)
            return ans2;
        else
            return ans1;
    }
    int search(int left,int right,vector<int>& r,int n,MountainArray &mountainArr)
    {
        while(left<=right)
        {
            int mid=(left+right)/2;
            int num;
            if(r[mid]==-1)
            {
               r[mid]=num=mountainArr.get(mid);
            }
            if(mid-1>=0&&r[mid-1]==-1)
                r[mid-1]=mountainArr.get(mid-1);
            if(mid+1<=n&&r[mid+1]==-1)
                r[mid+1]=mountainArr.get(mid+1);
            if(r[mid-1]!=-1&&r[mid+1]!=-1)
            {
                if(r[mid-1]<r[mid]&&r[mid]>r[mid+1])
                    return mid;
                else if(r[mid-1]>r[mid])
                    right=mid;
                else
                    left=mid;
            }
        }
        return -1;
    }
    int solve(int left,int right,vector<int>& r,int target,bool reverse,MountainArray &mountainArr)
    {
        while(left<=right)
        {
            int mid=(left+right)/2;
            if(r[mid]==-1)
               r[mid]=mountainArr.get(mid);
            if(r[mid]==target)
                return mid;
            else if(r[mid]>target)
            {
                if(reverse)
                    left=mid+1;
                else
                    right=mid-1;
            }
            else
            {
                if(reverse)
                    right=mid-1;
                else
                    left=mid+1;
            }
        }
        return -1;
    }
        
};