leetcode刷题记录(34)-简单

1.距离顺序排列矩阵单元格

题目：

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2) 之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

思路：先计算出每个矩阵的坐标，然后将矩阵转换为一维的数组，对数组进行排序

/**
 * @param {number} R
 * @param {number} C
 * @param {number} r0
 * @param {number} c0
 * @return {number[][]}
 */
var allCellsDistOrder = function(R, C, r0, c0) {
  let res = new Array(R).fill("").map(() => new Array(C));
  for (let i = 0; i < R; i++) {
    for (let j = 0; j < C; j++) {
      res[i][j] = [i, j];
    }
  }
  res = res.flat();
  return res.sort(
    (a, b) =>
      Math.abs(a[0] - r0) +
      Math.abs(a[1] - c0) -
      Math.abs(b[0] - r0) -
      Math.abs(b[1] - c0)
  );
};

2.移动石子直到连续

题目：

三枚石子放置在数轴上，位置分别为 a，b，c。

每一回合，我们假设这三枚石子当前分别位于位置 x, y, z 且 x < y < z。从位置 x 或者是位置 z 拿起一枚石子，并将该石子移动到某一整数位置 k 处，其中 x < k < z 且 k != y。

当你无法进行任何移动时，即，这些石子的位置连续时，游戏结束。

要使游戏结束，你可以执行的最小和最大移动次数分别是多少？ 以长度为 2 的数组形式返回答案：answer = [minimum_moves, maximum_moves]

思路：计算左侧和右侧最多可移动的次数。大就是左+右

/**
 * @param {number} a
 * @param {number} b
 * @param {number} c
 * @return {number[]}
 */
var numMovesStones = function(a, b, c) {
  const res = [a, b, c].sort((a, b) => a - b);
  const left = res[1] - res[0] - 1;
  const right = res[2] - res[1] - 1;
  let min = 0;
  let max = left + right;
  if (left || right) {
    if (left > 1 && right > 1) {
      min = 2;
    } else {
      min = 1;
    }
  }
  return [min, max];
};

3.有效的回旋镖

题目：

回旋镖定义为一组三个点，这些点各不相同且不在一条直线上。

给出平面上三个点组成的列表，判断这些点是否可以构成回旋镖。

思路：计算两个点的斜率，斜率不同，就不在一个直线上

也可以计算三条边的长度，能组成三角形，就不在一条直线上

/**
 * @param {number[][]} points
 * @return {boolean}
 */
var isBoomerang = function(points) {
   let dx1=points[0][0];
 let dx2=points[1][0];
 let dx3=points[2][0];
  let dy1=points[0][1];
 let dy2=points[1][1];
 let dy3=points[2][1];
 let ax1=dx1-dx2;
 let ay1=dy1-dy2;
 let ax2=dx1-dx3;
 let ay2=dy1-dy3;
 let k1=ay1/ax1;
 let k2=ay2/ax2;
 return k1!==k2&&!isNaN(k1)&&!isNaN(k2);

};

4.不邻接植花

题目：

有 N 个花园，按从 1 到 N 标记。在每个花园中，你打算种下四种花之一。

paths[i] = [x, y] 描述了花园 x 到花园 y 的双向路径。

另外，没有花园有 3 条以上的路径可以进入或者离开。

你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。

以数组形式返回选择的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用  1, 2, 3, 4 表示。保证存在答案。

思路：用map记录每个花园的相邻花园，然后从前往后遍历花园，保证花园的颜色和它相邻的花园已有的颜色不同即可

/**
 * @param {number} N
 * @param {number[][]} paths
 * @return {number[]}
 */
const getColor = (nei) => {
  for (let i = 1; i <= 4; i++) {
    if (!nei.includes(i)) return i;
  }
};
var gardenNoAdj = function (N, paths) {
  const map = new Map();
  for (const [a, b] of paths) {
    if (map.get(a)) {
      map.get(a).push(b);
    } else {
      map.set(a, [b]);
    }
    if (map.get(b)) {
      map.get(b).push(a);
    } else {
      map.set(b, [a]);
    }
  }
  const res = new Array(N);
  for (let i = 0; i < N; i++) {
    res[i] = getColor((map.get(i + 1)||[]).map((i) => res[i - 1]));
  }
  return res;
};

5.最后一块石头的重量

题目：

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

思路：和之前一题，有效的成对括号类似，用栈存储石头

/**
 * @param {number[]} stones
 * @return {number}
 */
var lastStoneWeight = function(stones) {
  stones.sort((a, b) => a - b);
  while (stones.length > 1) {
    const x = stones.pop();
    const y = stones.pop();
    if (x == y) continue;
    const index = stones.findIndex((i) => i >= x - y);
    stones.splice(index < 0 ? stones.length : index, 0, x - y);
  }
  return stones[0] || 0;
};