LeetCode #1057. Campus Bikes

最新推荐文章于 2021-06-22 08:12:20 发布

原创最新推荐文章于 2021-06-22 08:12:20 发布 · 408 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

625 篇文章

订阅专栏

本文介绍了一种解决校园2D网格中工人与自行车最优匹配的问题，通过计算Manhattan距离，采用桶排序策略，确保每个工人能被分配到最近且未被占用的自行车，实现资源的有效利用。

题目描述：

On a campus represented as a 2D grid, there are N workers and M bikes, with N <= M. Each worker and bike is a 2D coordinate on this grid.

Our goal is to assign a bike to each worker. Among the available bikes and workers, we choose the (worker, bike) pair with the shortest Manhattan distance between each other, and assign the bike to that worker. (If there are multiple (worker, bike) pairs with the same shortest Manhattan distance, we choose the pair with the smallest worker index; if there are multiple ways to do that, we choose the pair with the smallest bike index). We repeat this process until there are no available workers.

The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.

Return a vector ans of length N, where ans[i] is the index (0-indexed) of the bike that the i-th worker is assigned to.

Example 1:

Input: workers = [[0,0],[2,1]], bikes = [[1,2],[3,3]]
Output: [1,0]
Explanation: 
Worker 1 grabs Bike 0 as they are closest (without ties), and Worker 0 is assigned Bike 1. So the output is [1, 0].

Example 2:

Input: workers = [[0,0],[1,1],[2,0]], bikes = [[1,0],[2,2],[2,1]]
Output: [0,2,1]
Explanation: 
Worker 0 grabs Bike 0 at first. Worker 1 and Worker 2 share the same distance to Bike 2, thus Worker 1 is assigned to Bike 2, and Worker 2 will take Bike 1. So the output is [0,2,1].

Note:

0 <= workers[i][j], bikes[i][j] < 1000
All worker and bike locations are distinct.
1 <= workers.length <= bikes.length <= 1000

class Solution {
public:
    vector<int> assignBikes(vector<vector<int>>& workers, vector<vector<int>>& bikes) {
        int n=workers.size(), m=bikes.size();
        vector<vector<pair<int,int>>> dist(2001);
        // 运用桶排序，循环保证同一个桶内worker和bike的index从大到小排序
        for(int i=0;i<workers.size();i++)
        {
            for(int j=0;j<bikes.size();j++)
            {
                int x=abs(workers[i][0]-bikes[j][0])+abs(workers[i][1]-bikes[j][1]);
                dist[x].push_back({i,j});
            }
        }
        
        int count=0;
        vector<int> result(n,-1);
        unordered_set<int> assigned_bikes;
        for(int i=0;i<=2000;i++)
        {
            for(int j=0;j<dist[i].size();j++)
            {
                int worker=dist[i][j].first;
                int bike=dist[i][j].second;
                if(result[worker]==-1&&assigned_bikes.count(bike)==0)
                {
                    result[worker]=bike;
                    assigned_bikes.insert(bike);
                    count++;
                }
                if(count==n) return result;
            }
        }
        return result;
    }
};