zoukankan      html  css  js  c++  java
  • LeetCode447. Number of Boomerangs

    Description

    Given n points in the plane that are all pairwise distinct, a “boomerang” is a tuple of points (i, j, k) such that the distance between i and j equals the distance between i and k(the order of the tuple matters).

    Find the number of boomerangs. You may assume that n will be at most 500 and coordinates of points are all in the range [-10000, 10000] (inclusive).

    Example:
    Input: [[0,0],[1,0],[2,0]]
    Output: 2
    Explanation:
    The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]]

    my program

    思路:创建points.size()*points.size()的数组distance,存放每个点到各个点的距离的平方(距离的话需要开方,产生了浮点数,这里避免了),对数组的每一行元素进行排序,找出每行中某个元素相同的数目n,然后计数count累加(1+2+...+n)的和

    class Solution {
    public:
        int sum(int n) //求1~n的和
        {
            int res = 0;
            while(n)
            {
                res += n--;
            }
            return res;
        }
    
        int numberOfBoomerangs(vector<pair<int, int>>& points) {
            int count = 0;
            if(points.size() <= 2) return count;
            vector<vector<long long> > distance; 
            //points.size()*points.size()的数组
            //存放每个点到各个点的距离的平方(距离的话需要开方,产生了浮点数,这里避免了)
            for(int i = 0; i<points.size(); i++)    //初始化数组
            {
                vector<long long>temp(points.size(),0);
                distance.push_back(temp);
            }
            for(int i = 0;i<points.size(); i++)     //填充数组(计算距离平方填充)
            {
                for(int j = 0; j<points.size(); j++)
                {
                    long long x = points[i].first - points[j].first;
                    long long y = points[i].second - points[j].second;
                    distance[i][j] = x*x + y*y;
                }
            }
    
            for(int i = 0;i<points.size(); i++) 
            {
                sort(distance[i].begin(),distance[i].end());
                int j = 0;
                while(j<points.size()-1)
                {
                    int n = 0;
                    //每行中某个元素相同的数目
                    while(j<points.size()-1 && distance[i][j] == distance[i][j+1])
                    {
                        n++;
                        j++;
                    }
                    if( n != 0) count += sum(n)*2;
                    j++;
                }
            }
            return count;
        }
    };

    Submission Details
    31 / 31 test cases passed.
    Status: Accepted
    Runtime: 175 ms
    Your runtime beats 92.00% of cpp submissions.

    other methods

    For each point i, map<distance d, count of all points at distance d from i>.
    Given that count, choose 2 (with permutation) from it, to form a boomerang with point i.
    [use long appropriately for dx, dy and key; though not required for the given test cases]
    Time Complexity: O(n^2)

    int numberOfBoomerangs(vector<pair<int, int>>& points) {
    
        int res = 0;
    
        // iterate over all the points
        for (int i = 0; i < points.size(); ++i) {
    
            unordered_map<long, int> group(points.size());
    
            // iterate over all points other than points[i]
            for (int j = 0; j < points.size(); ++j) {
    
                if (j == i) continue;
    
                int dy = points[i].second - points[j].second;
                int dx = points[i].first - points[j].first;
    
                // compute squared euclidean distance from points[i]
                int key = dy * dy;
                key += dx * dx;
    
                // accumulate # of such "j"s that are "key" distance from "i"
                ++group[key];
            }
    
            for (auto& p : group) {
                if (p.second > 1) {
                    /*
                     * for all the groups of points, 
                     * number of ways to select 2 from n = 
                     * nP2 = n!/(n - 2)! = n * (n - 1)
                     */
                    res += p.second * (p.second - 1);
                }
            }
        }
    
        return res;
    }
    int numberOfBoomerangs(vector<pair<int, int>>& points) {
        int booms = 0;
        for (auto &p : points) {
            unordered_map<double, int> ctr(points.size());
            for (auto &q : points)
                booms += 2 * ctr[hypot(p.first - q.first, p.second - q.second)]++;
        }
        return booms;
    }

    Try each point as the “axis” of the boomerang, i.e., the “i” part of the triple. Group its distances to all other points by distance, counting the boomerangs as we go. No need to avoid q == p, as it’ll be alone in the distance == 0 group and thus won’t influence the outcome.

    Submitted five times, accepted in 1059, 1022, 1102, 1026 and 1052 ms, average is 1052.2 ms. The initial capacity for ctr isn’t necessary, just helps make it fast. Without it, I got accepted in 1542, 1309, 1302, 1306 and 1338 ms.

  • 相关阅读:
    ln 硬链接与软链接
    Fujitsu存储多路径管理
    Ansible 模块详解
    思科光纤交换机9124管理手册
    Fujitsu DX100S3配置方案
    富士通存储的TPP池和SDPV池
    Solaris 10 ZFS文件系统挂载
    经分测试M5000重启进入维护模式
    finally在return之后还是之前运行
    gradle构建
  • 原文地址:https://www.cnblogs.com/yangjiannr/p/7391348.html
Copyright © 2011-2022 走看看