网友：硕士5年了，税前才70w，感觉自己很失败。

最近在网上看到这样一个评论，一网友说自己硕士毕业5年了，税前才70w，感觉自己很失败。

d96d79c07cd7f93bd7ecd2ba94bcdb16.png

他的职位是后端开发，税前是70w，我们按照一年13到18薪来计算，当然能发到18薪是少数。按照这个区间来算的话，月薪大概在3.8w-5.38w之间。

硕士毕业5年的薪资不好查，在OfferShow上看下一个硕士校招的薪资，这里只统计后端开发，每个公司给到的薪资都不一样，也有一些可以给到30k的。毕业5年就算工资翻一倍，年薪也是能达到70w的。

1b189cc5e1f32e4876a660972f14959e.jpeg

c797cba3db190e9620213a40c813ef03.jpeg

15caaff9be46b8e149d9a61167f3fe97.jpeg

80c4d5d8bae7143ecb21cd949eccd620.jpeg

c1b78da0bf1b0981d621730aff21e7dd.jpeg

不过对于这位网友的言论，大多数人持有的是负面评论，我们可以看下。

e886c33139a7d843390264f90eb27239.jpeg

看完了薪资我们来看一道谷歌的面试题，这题是LeetCode的第447题：回旋镖的数量，一网友在谷歌面试的时候遇到这题，我们来看下。

30ee9b03f1e3c0b7c631df878d5924cd.png

问题描述

来源：LeetCode第447题

难度：中等

给定平面上 n 对 互不相同 的点 points ，其中 points[i] = [xi, yi] 。回旋镖 是由点 (i, j, k) 表示的元组 ，其中 i 和 j 之间的距离和 i 和 k 之间的欧式距离相等（需要考虑元组的顺序）。

返回平面上所有回旋镖的数量。

示例1：

输入：points = [[0,0],[1,0],[2,0]]

输出：2

解释：两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]

示例2：

输入：points = [[1,1],[2,2],[3,3]]

输出：2

  • n == points.length

  • 1 <= n <= 500

  • points[i].length == 2

  • -10^4 <= xi, yi <= 10^4

  • 所有点都 互不相同

问题分析

这题是让计算回旋镖的数量，回旋镖的形状如下，他有一个顶点，我们以当前顶点为起始点，计算当前顶点到其他所有点的距离。

3c278780914f0560e037f2c501fa357f.png

假如到当前顶点距离为m的有n条边，这n条边随便选择两条即可构成回旋镖，那么这n条边构成总的回旋镖（必须以当前点为顶点）数量为n*(n-1)，如果还有其他距离相同的边也可以构成回旋镖，只需要累加即可计算以当前点为顶点所构成的回旋镖的数量。

如果要计算所有回旋镖的数量，我们需要以每一个点为顶点都计算一遍即可，代码如下。

JAVA：

public int numberOfBoomerangs(int[][] points) {
    int res = 0;
    Map<Integer, Integer> map = new HashMap<>();
    for (int[] point1 : points) {// 以其中一个点为起始点，计算到其他所有点的距离。
        for (int[] point2 : points) {
            int dis = (point1[0] - point2[0]) * (point1[0] - point2[0])
                    + (point1[1] - point2[1]) * (point1[1] - point2[1]);
            map.put(dis, map.getOrDefault(dis, 0) + 1);
        }
        // 假如到当前点距离为m的有n条边，那么这n条边随便选择两条都可以构成回旋镖，
        // 所以组合的数量是n*(n-1)，这里只需要累加即可。
        for (int val : map.values())
            res += val * (val - 1);
        map.clear();// 这里要清空，下一步以下一个点为起始点计算。
    }
    return res;
}

C++：

public:
    int numberOfBoomerangs(vector<vector<int>>& points) {
        int res = 0;
        unordered_map<int, int> map;
        for (auto &point1 : points) {// 以其中一个点为起始点，计算到其他所有点的距离。
            for (auto &point2 : points) {
                int dis = (point1[0] - point2[0]) * (point1[0] - point2[0])
                        + (point1[1] - point2[1]) * (point1[1] - point2[1]);
                map[dis]++;
            }
            // 假如到当前点距离为m的有n条边，那么这n条边随便选择两条都可以构成回旋镖，
            // 所以组合的数量是n*(n-1)，这里只需要累加即可。
            for (const auto& kv : map)
            res += kv.second * (kv.second - 1);
            map.clear();// 这里要清空，下一步以下一个点为起始点计算。
        }
        return res;
    }

Python：

def numberOfBoomerangs(self, points: List[List[int]]) -> int:
    res = 0
    for point1 in points:# 以其中一个点为起始点，计算到其他所有点的距离。
        cnt = Counter()
        for point2 in points:
            dis = dist(point1, point2)
            cnt[dis] += 1
        for val in cnt.values():
            res += val * (val - 1)
    return res

C：

int distance(int* a, int* b) {
    return (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]);
}

typedef struct  {
    int key;
    int val;
    UT_hash_handle hh;
} hashTable;

hashTable* hashtable;

hashTable* find(int ikey) {
    hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

void insert(int ikey) {
    hashTable* it = find(ikey);
    if (it == NULL) {
        hashTable* tmp = malloc(sizeof(hashTable));
        tmp->key = ikey, tmp->val = 1;
        HASH_ADD_INT(hashtable, key, tmp);
    } else {
        it->val++;
    }
}

int numberOfBoomerangs(int **points, int pointsSize, int* pointsColSize) {
    int res = 0;
    for(int i = 0; i < pointsSize; i++) {
        for(int j = 0; j < pointsSize; j++) {
            int dis = distance(points[i],points[j]);
            insert(dis);
        }

        hashTable *curr = NULL, *tmp = NULL;
        HASH_ITER(hh, hashtable, curr, tmp) {
            hashTable* pEntry = find(curr->key);
            res += pEntry->val * (pEntry->val - 1);
            HASH_DEL(hashtable, curr);
            free(curr);
        }
    }
    return res;
}

-------------------------end-------------------------

笔者简介

博哥，真名：王一博，毕业十多年，《算法秘籍》作者，专注于数据结构和算法的讲解，在全球30多个算法网站中累计做题2000多道，在公众号中写算法题解700多题，对算法题有自己独特的解题思路和解题技巧，喜欢的可以给个关注，也可以下载我整理的1000多页的PDF算法文档。