leetcode 笔记

题目描述

n 块石头放置在二维平面中的一些整数坐标点上。每个坐标点上最多只能有一块石头。

如果一块石头的同行或者同列上有其他石头存在，那么就可以移除这块石头。

给你一个长度为 n 的数组 stones ，其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，返回可以移除的石子的最大数量。

示例 1：

输入：stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
输出：5
解释：一种移除 5 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,1] 同行。
2. 移除石头 [2,1] ，因为它和 [0,1] 同列。
3. 移除石头 [1,2] ，因为它和 [1,0] 同行。
4. 移除石头 [1,0] ，因为它和 [0,0] 同列。
5. 移除石头 [0,1] ，因为它和 [0,0] 同行。
石头 [0,0] 不能移除，因为它没有与另一块石头同行/列。
示例 2：

输入：stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
输出：3
解释：一种移除 3 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,0] 同行。
2. 移除石头 [2,0] ，因为它和 [0,0] 同列。
3. 移除石头 [0,2] ，因为它和 [0,0] 同行。
石头 [0,0] 和 [1,1] 不能移除，因为它们没有与另一块石头同行/列。
示例 3：

输入：stones = [[0,0]]
输出：0
解释：[0,0] 是平面上唯一一块石头，所以不可以移除它。
 

提示：

1 <= stones.length <= 1000
0 <= xi, yi <= 104
不会有两块石头放在同一个坐标点上

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

code

并查集，同行或同列的石头，可归为一族，每族只需要留1块石头。

c++

class Solution {
 private:
  unordered_map<int, int> par, lv;

  int find_parent(int x) {
    if (!par.count(x)) {
      lv[x] = 1;
      return par[x] = x;
    }
    return par[x] == x ? x : find_parent(par[x]);
  }

 public:
  int removeStones(vector<vector<int>>& stones) {
    for (auto& i : stones) {
      int p1 = find_parent(i[0]), p2 = find_parent(-i[1] - 1);
      if (p1 == p2) continue;
      if (lv[p1] < lv[p2]) swap(p1, p2);
      lv[p1] += lv.erase(p2);
      par[p2] = p1;
    }

    return stones.size() - lv.size();
  }
};

kotlin

class Solution {
    fun MutableMap<Int, Int>.findParent(x: Int): Int = if (this.getOrPut(x) { x } == x) x else findParent(this[x]!!)

    fun removeStones(stones: Array<IntArray>): Int =
        stones.size - stones.fold(mutableMapOf<Int, Int>()) { par, ints ->
            par[par.findParent(ints.first())] = par.findParent(-ints.last() - 1)
            par
        }.count { (k, v) -> k == v }
}

scala

import scala.annotation.tailrec
import scala.collection.mutable

object Solution {
  @tailrec
  private def findParent(par: mutable.Map[Int, Int], x: Int): Int = if (par.getOrElseUpdate(x, x) != x) findParent(par, par(x)) else x

  def removeStones(stones: Array[Array[Int]]): Int = 
    stones.length - stones.foldLeft(mutable.Map[Int, Int]())((par, i) => {
      par.update(findParent(par, i.head), findParent(par, -i.last - 1))
      par
    }).count(i => i._1 == i._2)
}

rust

use std::collections::HashMap;

impl Solution {
    pub fn remove_stones(stones: Vec<Vec<i32>>) -> i32 {
        fn findParent(par: &mut HashMap<i32, i32>, x: i32) -> i32 {
            if par.entry(x).or_insert(x).clone() != x {
                findParent(par, par[&x])
            } else {
                x
            }
        }

        let mut par = stones.iter().fold(HashMap::new(), |mut par, i| {
            let p1 = findParent(&mut par, i[0]);
            let p2 = findParent(&mut par, -i[1] - 1);
            par.insert(p2, p1);
            par
        });
        par.retain(|&k, &mut v| k == v);
        let ans = stones.len() as i32 - par.len() as i32;
        ans
    }
}