LeetCode第二十天

正曦08

已于 2022-08-07 15:44:02 修改

阅读量1.3k

点赞数

分类专栏：刷LeetCode 文章标签： leetcode 算法职场和发展

于 2022-08-07 15:43:39 首次发布

本文链接：https://blog.csdn.net/qq_57985179/article/details/126210852

版权

刷LeetCode 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一、螺旋矩阵

模拟

一层一层地输出所求值

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        vector <int> ans;
        for(int left = 0, right = n - 1, top = 0, bottom = m - 1; left <= right && top <= bottom;){
            for(int i = left; i < right; i++){
                ans.push_back(matrix[top][i]);
            }
            for(int i = top; i <= bottom; i++){
                ans.push_back(matrix[i][right]);
            }
            if(left < right && top < bottom){
                for(int i = right - 1; i > left; i--){
                    ans.push_back(matrix[bottom][i]);
                }
                for(int i = bottom; i > top; i--){
                    ans.push_back(matrix[i][left]);
                }
            }
            top++;
            left++;
            right--;
            bottom--;
        }
        return ans;
    }
};

二、最接近原点的k个点

插入排序（会超时）

class Solution {
public:
    int distance(vector<int>& point){
        return point[0] * point[0] + point[1] * point[1];
    }
    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
        int n = points.size();
        for(int i = 1; i < n; i++){
            for(int j = i; j > 0; j--){
                if(distance(points[j]) < distance(points[j - 1])){
                    vector<int> tmp = points[j];
                    points[j] = points[j - 1];
                    points[j - 1] = tmp;
                }
            }
        }
        vector<vector<int>> ans;
        for(int i = 0; i < k; i++)
            ans.push_back(points[i]);
        return ans;
    }
};

快排（但还是很慢）

勉强通过了，但是耗时很长，1点多秒。

class Solution {
public:
    int distance(vector<int>& point){
        return point[0] * point[0] + point[1] * point[1];
    }
    void quickSort(vector<vector<int>>& points, int left, int right){
        if(left >= right) return;
        int i = left;
        int j = right;
        vector<int> key = points[left];
        int flag = distance(key);
        while(i < j){
            while(i < j && flag <= distance(points[j]))
                j--;
            points[i] = points[j];

            while(i < j && flag >= distance(points[i]))
                i++;
            points[j] = points[i];
        }
        points[i] = key;
        quickSort(points, left, i - 1);
        quickSort(points, i + 1, right);
    }
    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
        int n = points.size();
        quickSort(points, 0, n - 1);
        return {points.begin(), points.begin() + k};
    }
};

用内置sort函数进行排序

class Solution {
public:
    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
        sort(points.begin(), points.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] * u[0] + u[1] * u[1] < v[0] * v[0] + v[1] * v[1];
        });
        return {points.begin(), points.begin() + k};
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/k-closest-points-to-origin/solution/zui-jie-jin-yuan-dian-de-k-ge-dian-by-leetcode-sol/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

堆排（官方的）

class Solution {
public:
    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
        priority_queue<pair<int, int>> q;
        for (int i = 0; i < k; ++i) {
            q.emplace(points[i][0] * points[i][0] + points[i][1] * points[i][1], i);
        }
        int n = points.size();
        for (int i = k; i < n; ++i) {
            int dist = points[i][0] * points[i][0] + points[i][1] * points[i][1];
            if (dist < q.top().first) {
                q.pop();
                q.emplace(dist, i);
            }
        }
        vector<vector<int>> ans;
        while (!q.empty()) {
            ans.push_back(points[q.top().second]);
            q.pop();
        }
        return ans;
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/k-closest-points-to-origin/solution/zui-jie-jin-yuan-dian-de-k-ge-dian-by-leetcode-sol/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

快排（官方的）

对比起来，还是快排最快，但是自己写的需要进行优化，只能说还需多加学习。

class Solution {
private:
    mt19937 gen{random_device{}()};

public:
    void random_select(vector<vector<int>>& points, int left, int right, int k) {
        int pivot_id = uniform_int_distribution<int>{left, right}(gen);
        int pivot = points[pivot_id][0] * points[pivot_id][0] + points[pivot_id][1] * points[pivot_id][1];
        swap(points[right], points[pivot_id]);
        int i = left - 1;
        for (int j = left; j < right; ++j) {
            int dist = points[j][0] * points[j][0] + points[j][1] * points[j][1];
            if (dist <= pivot) {
                ++i;
                swap(points[i], points[j]);
            }
        }
        ++i;
        swap(points[i], points[right]);
        // [left, i-1] 都小于等于 pivot, [i+1, right] 都大于 pivot
        if (k < i - left + 1) {
            random_select(points, left, i - 1, k);
        }
        else if (k > i - left + 1) {
            random_select(points, i + 1, right, k - (i - left + 1));
        }
    }

    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
        int n = points.size();
        random_select(points, 0, n - 1, k);
        return {points.begin(), points.begin() + k};
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/k-closest-points-to-origin/solution/zui-jie-jin-yuan-dian-de-k-ge-dian-by-leetcode-sol/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。