LeetCodeGOGOGO刷題記07——備戰Amazon（Online_Assessment前的終章）

1122. Relative Sort Array

難度：

Easy

思路：

給定一個array和一個set，保證set中的元素均在array中出現了，要求將array按照set中的順序排序，對於未在set中出現的元素從小到大排在array末尾

複雜排序，考慮到直接建立一個新數據結構專門進行排序，num表示該數數值，value表示該數在set中出現的位置，對於未在set中出現的元素，其value標記爲set大小（即set末位置後的位置）。預處理set，之後對於新數據結構進行排序即可。

代碼：

/*
Author Owen_Q
*/


class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        int n = arr1.size();
        int p = arr2.size();
        vector<int> pos(1010,p);
        for(int i=0;i<p;i++)
            pos[arr2[i]] = i;
        vector<Sa> s;
        s.clear();
        for(int i=0;i<n;i++)
        {
            Sa temp;
            temp.num = arr1[i];
            temp.value = pos[temp.num];
            s.push_back(temp);
        }
        sort(s.begin(),s.end());
        vector<int> re;
        re.clear();
        for(Sa i:s)
            re.push_back(i.num);
        return re;
    }
private:
    typedef struct SA
    {
        int num;
        int value;
        
        bool operator <(const struct SA &a)const
        {
            if(value<a.value)
                return true;
            else if(value==a.value&&num<a.num)
                return true;
            else
                return false;
        }
    }Sa;
};

346. Moving Average from Data Stream

難度：

Easy

思路：

用queue來模擬一個FIFO的cache

代碼：

/*
Author Owen_Q
*/


class MovingAverage {
public:
    /** Initialize your data structure here. */
    MovingAverage(int size) {
        n = size;
        while(!q.empty())
            q.pop();
        sum = 0;
    }
    
    double next(int val) {
        q.push(val);
        sum += val;
        int m = q.size();
        if(m>n)
        {
            m--;
            sum -= q.front();
            q.pop();
        }
        return (double)(sum) / (double)(m);
    }
private:
    int n;
    queue<int> q;
    int sum;
};

/**
 * Your MovingAverage object will be instantiated and called as such:
 * MovingAverage* obj = new MovingAverage(size);
 * double param_1 = obj->next(val);
 */

1128. Number of Equivalent Domino Pairs

難度：

Easy

思路：

統計相同的pair對數

由於pair的兩個元素均爲一位數，於是可以直接將pair的兩個元素哈希成一個兩位數，然後進行計數，最後對於同一個哈希統計下的pair，利用計數公式  計算即可

代碼：

/*
Author Owen_Q
*/

class Solution {
public:
    int numEquivDominoPairs(vector<vector<int>>& dominoes) {
        vector<int> num(100,0);
        for(auto d:dominoes)
        {
            if(d[0]>d[1])
                num[d[0]+d[1]*10]++;
            else
                num[d[1]+d[0]*10]++;
        }
        int sum = 0;
        for(int i=1;i<100;i++)
        {
            sum += num[i]*(num[i]-1)/2;
        }
        return sum;
    }
};

42. Trapping Rain Water

難度：

Hard

思路：

求一個一維山脈的最大容積，由於每個位置的可容高度是左右側最大高度的最小值，於是先預處理兩側最大高度，再求個最小值即可得到

代碼：

/*
Author Owen_Q
*/


class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if(n==0)
            return 0;
        vector<int> l(n,0);
        vector<int> r(n,0);
        l[0] = height[0];
        r[n-1] = height[n-1];
        for(int i=1;i<n;i++)
        {
            l[i] = max(height[i],l[i-1]);
            r[n-1-i] = max(height[n-1-i],r[n-i]);
        }
        int sum = 0;
        for(int i=0;i<n;i++)
        {
            sum += min(l[i],r[i]) - height[i];
        }
        return sum;
    }
};

 

 

這應該是Amazon online assessment階段最後一次刷題了，加油