神仙公司名单（杭州）

神仙公司（杭州）

你懂的系列，神仙公司，走起。

说起杭州，不管是哪个行业的打工人，都会不约而同地想起辣个公司。

甚至在 2008 年，杭州还被官方授予了"中国电子商务之都"之称，可见这座城市与中国互联网腾飞发展 20 年的关系有多密切。

但，三十年河东三十年河西，最近辣个公司虽说完成了三年整改，宣称进入新的发展起点，但时间只会往前，有些局面变了就很难回去了。

但不管怎么样，杭州还是成为很好的土壤，孕育了很多优秀的企业，今天我们就一起看看杭州有那些神仙公司：

• Zoom：老牌 WLB 典范，965，弹性工作，每周可居家办公一天，足额六险一金，额外补充全面商业险，18 天年假，20 天带薪病假，员工持股计划，每天零食下午茶，月度餐补和节日福利，薪资水平 25k~60k，14薪；

• 微策略：大数据类上市公司，965，不加班，每周一居家办公，六险一金，额外补充医疗保险，20 天年假，10 天带薪病假，每日水果零食下午茶，公司内配有游戏室，健身房，母婴房，节日福利，薪资水平 18k~40k，13薪~15薪；

• 道富：外企类互联网金融公司，955，六险一金，额外补充医疗保险，15 天年假，20 天带薪病假，节日福利，每年体检，节日福利，20k~50k，13薪~15薪；

• 游卡桌游：游戏类 IT 公司，总部在杭州，美日韩均有布局，有出国机会，员工近 2000 人，热门产品《三国杀》。双休不卷，弹性工作，工作范围轻松，六险一金，额外补充子女医疗保险，餐补，零食下午茶，定期体检，薪资水平 20k~50k；

• 鸿程系统：国企背景 IT 公司，早 8:30 晚 5:30（偶尔加班），午休 2 小时，六险一金，免费食堂，应届生房补，在招岗位薪资水平 15k~30k，13 薪；

• 影视飓风：人员规模不足 300 人，但有却有自己的园区，早10晚7，弹性工作，双休，办公条件优越，五险一金，员工旅游，节日福利，团建很多，每天零食下午茶，每周团建聚餐，每年人手一台新款 iPhone Pro，日常有各种实用福利，符合一切年轻人对首份理想工作的想象，学历要求不高，薪资水平 10k~25k；

以上就是坐标「杭州」的各行业神仙公司。

关于「杭州」以及「杭州神仙公司」，你有什么想分享的呢，欢迎评论区留言。

...

回归主题。

周末，来一道简单算法题，维持大脑清醒。

题目描述

平台：LeetCode

题号：766

给你一个 m x n 的矩阵 matrix。

如果这个矩阵是托普利茨矩阵，返回 true；否则，返回 false。

如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是托普利茨矩阵。

示例 1：

输入：matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]
输出：true
解释：
在上述矩阵中, 其对角线为: 
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。 
各条对角线上的所有元素均相同, 因此答案是 True 。

示例 2：

输入：matrix = [[1,2],[2,2]]
输出：false
解释：
对角线 "[1, 2]" 上的元素不同。

提示：

进阶：

• 如果矩阵存储在磁盘上，并且内存有限，以至于一次最多只能将矩阵的一行加载到内存中，该怎么办？
• 如果矩阵太大，以至于一次只能将不完整的一行加载到内存中，该怎么办？

按「格子」遍历

对于一个合格的「托普利茨矩阵」而言，每个格子总是与其左上角格子相等（如果有的话）。

我们以「格子」为单位进行遍历，每次与左上角的格子进行检查即可。

这样我们每对一个格子进行判断，都要读 matrix 上的两个格子的值（即「非边缘格子其实会被读取两次」）。

Java 代码：

class Solution {
    public boolean isToeplitzMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] != matrix[i - 1][j - 1]) return false;
            }
        }
        return true;
    }
}

C++ 代码：

class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] != matrix[i - 1][j - 1]) return false;
            }
        }
        return true;
    }
};

Python 代码：

class Solution:
    def isToeplitzMatrix(self, matrix: List[List[int]]) -> bool:
        m, n = len(matrix), len(matrix[0])
        for i in range(1, m):
            for j in range(1, n):
                if matrix[i][j] != matrix[i - 1][j - 1]:
                    return False
        return True

TypeScript 代码：

function isToeplitzMatrix(matrix: number[][]): boolean {
    const m: number = matrix.length, n: number = matrix[0].length;
    for (let i: number = 1; i < m; i++) {
        for (let j: number = 1; j < n; j++) {
            if (matrix[i][j] !== matrix[i - 1][j - 1]) return false;
        }
    }
    return true;
};

• 时间复杂度：
• 空间复杂度：

按「线」遍历

如果稍微增加一点点难度：限制每个格子只能被读取一次呢？

这时候我们也可以按照「线」为单位进行检查。

当一条完整的斜线值都相等，我们再对下一条斜线做检查。

这样对于每个格子，我们都是「严格只读取一次」（如果整个矩阵是存在磁盘中，且不考虑操作系统的按页读取等机制，那么 IO 成本将下降为原来的一半）。

Java 代码：

class Solution {
    public boolean isToeplitzMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int row = m, col = n;
        while (col-- > 0) {
            for (int i = 0, j = col, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
                if (matrix[i][j] != val) return false;
            }
        }
        while (row-- > 0) {
            for (int i = row, j = 0, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
                if (matrix[i][j] != val) return false;
            }
        }
        return true;
    }
}

C++ 代码：

class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        int row = m, col = n;
        while (col-- > 0) {
            for (int i = 0, j = col, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
                if (matrix[i][j] != val) return false;
            }
        }
        while (row-- > 0) {
            for (int i = row, j = 0, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
                if (matrix[i][j] != val) return false;
            }
        }
        return true;
    }
};

Python 代码：

class Solution:
    def isToeplitzMatrix(self, matrix: List[List[int]]) -> bool:
        m, n = len(matrix), len(matrix[0])
        row, col = m, n
        while col > 0:
            col -= 1
            i, j, val = 1, col + 1, matrix[0][col]
            while i < m and j < n:
                if matrix[i][j] != val:
                    return False
                i, j = i + 1, j + 1
        while row > 0:
            row -= 1
            i, j, val = row + 1, 1, matrix[row][0]
            while i < m and j < n:
                if matrix[i][j] != val:
                    return False
                i, j = i + 1, j + 1
        return True

TypeScript 代码：

function isToeplitzMatrix(matrix: number[][]): boolean {
    const m = matrix.length, n = matrix[0].length;
    let row = m, col = n;
    while (col-- > 0) {
        for (let i: number = 0, j: number = col, val: number = matrix[i++][j++]; i < m && j < n; i++, j++) {
            if (matrix[i][j] !== val) return false;
        }
    }
    while (row-- > 0) {
        for (let i: number = row, j: number = 0, val: number = matrix[i++][j++]; i < m && j < n; i++, j++) {
            if (matrix[i][j] !== val) return false;
        }
    }
    return true;
};

• 时间复杂度：
• 空间复杂度：

进阶

1. 如果矩阵存储在磁盘上，并且内存有限，以至于一次最多只能将矩阵的一行加载到内存中，该怎么办？

使用「背包问题」的一维优化思路：假设我们有装载一行数据大小的内存，每次读取新的行时都进行「从右往左」的覆盖，每次覆盖都与前一个位置的进行比较（其实就是和上一行的左上角位置进行比较）。

如图：

如果你对更多「背包问题」相关内容感兴趣，可以看我这个系列：背包问题

2. 如果矩阵太大，以至于一次只能将不完整的一行加载到内存中，该怎么办？

将问题看做子问题进行解决：调整读取矩阵的方式（按照垂直方向进行读取）；或使用额外数据记录当前当前片段的行/列数。 更为合理的解决方案是：存储的时候按照「数组」的形式进行存储（行式存储），然后读取的时候计算偏移量直接读取其「左上角」或者「右下角」的值。

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉