还是何同学
昨天聊了 何同学最新视频滥用开源 的事儿。
很多喜欢何同学的网友，开始迫不及待的"纠正"我 🤣🤣🤣
对于一些只有感情宣泄的评论，我就不回应了，着重回应一些"看着很有道理"的说法。
例如："这个开源项目使用的 MIT 协议，怎么改都可以的，何同学没做错。"
首先，这个开源项目确实使用的 MIT 协议，该协议可以说是全世界最宽松的开源协议之一，几乎仅次于 Unlicense（无许可证）。
该协议「无专利诉讼保护、无歧视性条款、无担保、无责任限制、无强制开源、全球适用、商业友好」，但即使是如此宽松的协议也是有使用要求的，甚至可以说是唯一的要求，那就是 在使用的时候，保留原作者的版权声明和免责声明。
也就是说何同学「删除原作者署名」的做法，就是明确违反 MIT 协议的，说其"滥用开源项目"其实已经属于言轻了。
违反协议，去掉署名，同时又是商用（拍摄的视频是商单视频），这其实已经是违法行为了。
至于为什么何同学得到的惩罚，不涉及法律，更多只是网络舆论谴责？主要原因有两个：
-
这片土地，对于开源协议（乃至开源行为本身）不够重视，而且对于此种案例的追责问题，还处于空白阶段 -
原作者选择不追究。从原作者对何同学工作室的回复邮件截图中，可以看到原作者表示"在版权成为问题的地方，希望何同学的团队能够有效合作，确保这个问题不会再次发生"。同时，该作者表示自己不需要任何赔偿
对，仅此而已。
不用负法律责任，不是犯的错误有多小，而是运气好。
...
不过经过这一出，我开始理解，为什么网上讨厌何同学的人这么多。
或许一个占比不少的原因，是其「饭圈类的粉丝」实在太多，这些粉丝，只是听说了「MIT 是极其宽松的开源协议」就迫不及待到处宣扬「何同学用到的项目是 MIT，他的做法是被允许的」的观点，甚至连简单看一眼完整协议都做不到（即便 MIT 协议只有简单的几句话）。
...
回归主题。
来一道和 HOT 100 级别的算法题。
题目描述
平台：LeetCode
题号：54
给你一个
行
列的矩阵 matrix，请按照顺时针螺旋顺序，返回矩阵中的所有元素。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
提示：
按照「形状」进行模拟
我们可以按「圈」进行划分打印。
使用「左上角」 &「右下角」 来确定某个「圈」，进行打印。
完成后，令「左上角」&「右下角」往里收，分别得到 和 ，执行相同的打印规则。
Java 代码：
class Solution {
public List<Integer> spiralOrder(int[][] mat) {
List<Integer> ans = new ArrayList<>();
int m = mat.length, n = mat[0].length;
circle(mat, 0, 0, m - 1, n - 1, ans);
return ans;
}
// 遍历 以 (x1, y1) 作为左上角，(x2, y2) 作为右下角形成的「圈」
void circle(int[][] mat, int x1, int y1, int x2, int y2, List<Integer> ans) {
if (x2 < x1 || y2 < y1) return;
// 只有一行时，按「行」遍历
if (x1 == x2) {
for (int i = y1; i <= y2; i++) ans.add(mat[x1][i]);
return;
}
// 只有一列时，按「列」遍历
if (y1 == y2) {
for (int i = x1; i <= x2; i++) ans.add(mat[i][y1]);
return;
}
// 遍历当前「圈」
for (int i = y1; i < y2; i++) ans.add(mat[x1][i]);
for (int i = x1; i < x2; i++) ans.add(mat[i][y2]);
for (int i = y2; i > y1; i--) ans.add(mat[x2][i]);
for (int i = x2; i > x1; i--) ans.add(mat[i][y1]);
// 往里收一圈，继续遍历
circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans);
}
}
C++ 代码：
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& mat) {
vector<int> ans;
int m = mat.size(), n = mat[0].size();
circle(mat, 0, 0, m - 1, n - 1, ans);
return ans;
}
void circle(vector<vector<int>>& mat, int x1, int y1, int x2, int y2, vector<int>& ans) {
if (x2 < x1 || y2 < y1) return;
if (x1 == x2) {
for (int i = y1; i <= y2; i++) ans.push_back(mat[x1][i]);
return;
}
if (y1 == y2) {
for (int i = x1; i <= x2; i++) ans.push_back(mat[i][y1]);
return;
}
for (int i = y1; i < y2; i++) ans.push_back(mat[x1][i]);
for (int i = x1; i < x2; i++) ans.push_back(mat[i][y2]);
for (int i = y2; i > y1; i--) ans.push_back(mat[x2][i]);
for (int i = x2; i > x1; i--) ans.push_back(mat[i][y1]);
circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans);
}
};
Python 代码：
class Solution:
def spiralOrder(self, mat: List[List[int]]) -> List[int]:
ans = []
m, n = len(mat), len(mat[0])
self.circle(mat, 0, 0, m - 1, n - 1, ans)
return ans
def circle(self, mat, x1, y1, x2, y2, ans):
if x2 < x1 or y2 < y1:
return
if x1 == x2:
for i in range(y1, y2 + 1):
ans.append(mat[x1][i])
return
if y1 == y2:
for i in range(x1, x2 + 1):
ans.append(mat[i][y1])
return
for i in range(y1, y2):
ans.append(mat[x1][i])
for i in range(x1, x2):
ans.append(mat[i][y2])
for i in range(y2, y1, -1):
ans.append(mat[x2][i])
for i in range(x2, x1, -1):
ans.append(mat[i][y1])
self.circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans)
TypeScirpt 代码：
function circle(mat: number[][], x1: number, y1: number, x2: number, y2: number, ans: number[]): void {
if (x2 < x1 || y2 < y1) return;
if (x1 === x2) {
for (let i = y1; i <= y2; i++) ans.push(mat[x1][i]);
return;
}
if (y1 === y2) {
for (let i = x1; i <= x2; i++) ans.push(mat[i][y1]);
return;
}
for (let i = y1; i < y2; i++) ans.push(mat[x1][i]);
for (let i = x1; i < x2; i++) ans.push(mat[i][y2]);
for (let i = y2; i > y1; i--) ans.push(mat[x2][i]);
for (let i = x2; i > x1; i--) ans.push(mat[i][y1]);
circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans);
}
function spiralOrder(mat: number[][]): number[] {
const ans = [];
const m = mat.length, n = mat[0].length;
circle(mat, 0, 0, m - 1, n - 1, ans);
return ans;
};
-
时间复杂度： -
空间复杂度：
按照「方向」进行模拟
事实上，我们还可以根据「方向」进行模拟。
因为每一圈的打印输出都是按照特定的「四个方向」进行的。
这种解法更为简洁。而触发方向转换的时机：
-
下一步发生位置溢出 -
回到了本圈的起点
Java 代码：
class Solution {
public List<Integer> spiralOrder(int[][] mat) {
List<Integer> ans = new ArrayList<>();
int m = mat.length, n = mat[0].length, INF = 101;
// 定义四个方向
int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};
for (int x = 0, y = 0, d = 0, i = 0; i < m * n; i++) {
ans.add(mat[x][y]);
mat[x][y] = INF;
// 下一步要到达的位置
int nx = x + dirs[d][0], ny = y + dirs[d][1];
// 如果下一步发生「溢出」或者已经访问过（说明四个方向已经走过一次）
if (nx < 0 || nx >= m || ny < 0 || ny >= n || mat[nx][ny] == INF) {
d = (d + 1) % 4;
nx = x + dirs[d][0]; ny = y + dirs[d][1];
}
x = nx; y = ny;
}
return ans;
}
}
C++ 代码：
class Solution {
public:
const int dir[4][2] = {{0,1}, {1,0},{0,-1},{-1,0}};
vector<int> spiralOrder(vector<vector<int>>& mat) {
vector<int> ans;
int m = mat.size(), n = mat[0].size(), INF = 101;
for(int x = 0, y = 0, d = 0, i = 0; i < m * n; i++){
ans.push_back(mat[x][y]);
mat[x][y] = INF;
int nx = x + dir[d][0], ny = y + dir[d][1];
if(nx < 0 || nx >= m || ny < 0 || ny >= n || mat[nx][ny] == INF){
d = (d + 1) % 4;
nx = x + dir[d][0], ny = y + dir[d][1];
}
x = nx, y = ny;
}
return ans;
}
};
Python 代码：
class Solution:
def spiralOrder(self, mat: List[List[int]]) -> List[int]:
ans = []
m, n, INF = len(mat), len(mat[0]), 101
dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
x, y, d, i = 0, 0, 0, 0
while i < m * n:
ans.append(mat[x][y])
mat[x][y] = INF
nx, ny = x + dirs[d][0], y + dirs[d][1]
if nx < 0 or nx >= m or ny < 0 or ny >= n or mat[nx][ny] == INF:
d = (d + 1) % 4
nx, ny = x + dirs[d][0], y + dirs[d][1]
x, y = nx, ny
i += 1
return ans
TypeScirpt 代码：
function spiralOrder(mat: number[][]): number[] {
const ans = [];
const m = mat.length, n = mat[0].length, INF = 101;
const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
for (let x = 0, y = 0, d = 0, i = 0; i < m * n; i++) {
ans.push(mat[x][y]);
mat[x][y] = INF;
let nx = x + dirs[d][0], ny = y + dirs[d][1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n || mat[nx][ny] === INF) {
d = (d + 1) % 4;
nx = x + dirs[d][0]; ny = y + dirs[d][1];
}
x = nx; y = ny;
}
return ans;
};
-
时间复杂度： -
空间复杂度：
最后
巨划算的 LeetCode 会员优惠通道目前仍可用 ~
使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。
我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。
欢迎关注，明天见。
更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
