LeetCode 214场周赛（2020/11/01）

1. 能否连接形成数组

哈希表

其实比赛时第一题还想了好一会儿。其实这题思路很简单，用一个哈希表保存一维数组各个数字的位置。然后遍历二维数组pieces，然后对于pieces的每一个数组，判断该数组的值是否在一维数组中，是否在一维数组的位置是连续的即可。

class Solution {
public:
    bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
        map<int,int> m1;
        for(int i=0;i<arr.size();i++)
        {
            m1[arr[i]] = i+1;
        }
        for(auto piece : pieces)
        {
            int num = piece[0];
            int prev = m1[num];
            if(!prev)
                return false;
            for(int i=1;i<piece.size();i++)
            {
                num = piece[i];
                if(!m1[num]||m1[num]!=prev+1)
                    return false;
                prev = m1[num];
            }
        }
        return true;
    }
};

2. 统计字典序元音字符串的数目

思维

设一个一维数组，分别表示以a, e, i, o, u结尾的字符串个数。

class Solution {
public:
    int countVowelStrings(int n) {
        vector<vector<int>> cnt(n+1, vector<int>(5));
        for(int i=0;i<5;i++)
            cnt[1][i] = 1;
        int ans = 0;
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<5;j++)
            {
                cnt[i][j] = cnt[i-1][j];
                if(j>0)
                    cnt[i][j] += cnt[i][j-1];
            }
        }
        for(int i=0;i<5;i++)
            ans += cnt[n][i];
        return ans;
        
        
    }
};

3. 可以到达的最远建筑

二分

竞赛时想到的是二分法。二分答案，然后用贪心方法判断是否能达到该位置。二分复杂度O(logN)，判断的复杂度为O(NlogN+N)。结果是1544ms险过。

class Solution {
public:
    bool judge(vector<int>&heights, int n, int bricks, int ladders)
    {
        vector<int> needs;
        for(int i=1;i<=n;i++)
        {
            if(heights[i]>heights[i-1])
                needs.push_back(heights[i]-heights[i-1]);
        }
        sort(needs.begin(),needs.end(), greater<int>());
        int sum  =0;
        for(int i=ladders;i<needs.size();i++)
        {
            sum += needs[i];
            if(sum > bricks)
                return false;
        }
        return true;
    }
    int furthestBuilding(vector<int>& heights, int bricks, int ladders) {
        int N = heights.size();
        int le = 0;
        int ri = N;
        int mid = (le+ri)/2;
        while(le<ri)
        {
            mid = (le+ri)/2;
            //可以攀爬
            if(judge(heights,mid,bricks,ladders))
                le = mid + 1;
            else ri = mid;
        }
        return le-1;
    }
};

贪心

参考零神代码
参考链接

class Solution {
public:
    int furthestBuilding(vector<int>& heights, int bricks, int ladders) {
        int N = heights.size();
        priority_queue<int, vector<int>, greater<int>> que;
        int sumH = 0;
        for(int i=1;i<N;i++)
        {
            int delta = heights[i] - heights[i-1];
            if(delta > 0)
                que.push(delta);
            if(que.size()>ladders)
            {
                sumH += que.top();
                que.pop();
            }
            if(sumH > bricks)
                return i-1;
        }
        return N - 1;
    }
};

4. 第K条最小指令

组合数（妙啊）

这是个数学问题，没想到，比赛时没A掉。
参考零神代码
参考链接

class Solution {
public:
    string kthSmallestPath(vector<int>& destination, int k) {
        int Hcnt = destination[1];
        int Vcnt = destination[0];
        vector<vector<int>> comb(Vcnt+Hcnt, vector<int>(Hcnt));
        comb[0][0] = 1;
        for(int i=1; i < Vcnt+Hcnt; i++)
        {
            comb[i][0] = 1;
            for(int j = 1; j <=i && j < Hcnt; j++)
            {
                comb[i][j] = comb[i-1][j-1] + comb[i-1][j];
            }
        }
        string ans;
        int N = Hcnt+Vcnt;
        for(int i=0; i < N; i++)
        {
            if(Hcnt>0)
            {
                int num = comb[Hcnt+Vcnt-1][Hcnt-1];
                if(k>num)
                {
                    Vcnt--;
                    ans += 'V';
                    k -= num;
                }
                else{
                    ans += 'H';
                    Hcnt--;
                }
            }
            else {
                ans += 'V';
                Vcnt--;
            };
        }
        return ans;
    }
};