根据同一 Vec 的其他元素删除 Vec 元素的最佳方法

Question

我有一个集合向量，我想删除向量中其他集合的子集的所有集合。示例：

a = {0, 3, 5}
b = {0, 5}
c = {0, 2, 3}

在这种情况下，我想删除 b，因为它是 a 的子集。我可以使用“哑” n² 算法。

遗憾的是，让它与借用检查器一起工作非常棘手。我想出的最好的是（Playground）：

let mut v: Vec<HashSet<u8>> = vec![];

let mut to_delete = Vec::new();
for (i, set_a) in v.iter().enumerate().rev() {
    for set_b in &v[..i] {
        if set_a.is_subset(&set_b) {
            to_delete.push(i);
            break;
        }
    }
}

for i in to_delete {
    v.swap_remove(i);
}

（注意：上面的代码是不正确的！更多细节见cmets）

我看到了一些缺点：

• 我需要一个带有额外分配的额外向量
• 也许有比经常致电swap_remove 更有效的方法
• 如果我需要保持秩序，我不能使用swap_remove，但必须使用remove，这很慢

有没有更好的方法来做到这一点？我不只是询问我的用例，而是询问标题中描述的一般情况。

Answer 1

这是一个不进行额外分配并保留顺序的解决方案：

fn product_retain<T, F>(v: &mut Vec<T>, mut pred: F)
    where F: FnMut(&T, &T) -> bool
{
    let mut j = 0;
    for i in 0..v.len() {
        // invariants:
        // items v[0..j] will be kept
        // items v[j..i] will be removed
        if (0..j).chain(i + 1..v.len()).all(|a| pred(&v[i], &v[a])) {
            v.swap(i, j);
            j += 1;
        }
    }
    v.truncate(j);
}

fn main() {
    // test with a simpler example
    // unique elements
    let mut v = vec![1, 2, 3];
    product_retain(&mut v, |a, b| a != b);
    assert_eq!(vec![1, 2, 3], v);

    let mut v = vec![1, 3, 2, 4, 5, 1, 2, 4];
    product_retain(&mut v, |a, b| a != b);
    assert_eq!(vec![3, 5, 1, 2, 4], v);
}

这是一种分区算法。第一个分区中的元素将被保留，第二个分区中的元素将被删除。

Answer 2

您可以使用while 循环代替for：

use std::collections::HashSet;

fn main() {
    let arr: &[&[u8]] = &[
        &[3],
        &[1,2,3],
        &[1,3],
        &[1,4],
        &[2,3]
    ];

    let mut v:Vec<HashSet<u8>> = arr.iter()
        .map(|x| x.iter().cloned().collect())
        .collect();

    let mut pos = 0;
    while pos < v.len() {
        let is_sub = v[pos+1..].iter().any(|x| v[pos].is_subset(x)) 
            || v[..pos].iter().any(|x| v[pos].is_subset(x));

        if is_sub {
            v.swap_remove(pos);
        } else {
            pos+=1;
        }
    }
    println!("{:?}", v);
}

没有额外的分配。

---

为避免使用remove和swap_remove，可以将向量的类型改为Vec<Option<HashSet<u8>>>：

use std::collections::HashSet;

fn main() {
    let arr: &[&[u8]] = &[
        &[3],
        &[1,2,3],
        &[1,3],
        &[1,4],
        &[2,3]
    ];

    let mut v:Vec<Option<HashSet<u8>>> = arr.iter()
        .map(|x| Some(x.iter().cloned().collect()))
        .collect();

    for pos in 0..v.len(){
        let is_sub = match v[pos].as_ref() {
            Some(chk) => 
                v[..pos].iter().flat_map(|x| x).any(|x| chk.is_subset(x)) 
                ||  v[pos+1..].iter().flat_map(|x| x).any(|x| chk.is_subset(x)),
            None => false,
        };

        if is_sub { v[pos]=None };//Replace with None instead remove

    }
    println!("{:?}", v);//[None, Some({3, 2, 1}), None, Some({1, 4}), None]
}

Answer 3

• 我需要一个带有额外分配的额外向量

我不会担心这种分配，因为与算法的其余部分相比，该分配的内存和运行时占用空间非常小。

• 也许有比经常致电swap_remove 更有效的方法。
• 如果我需要保持秩序，我不能使用swap_remove,，但必须使用remove，这很慢

我将 to_delete 从 Vec<usize> 更改为 Vec<bool> 并标记是否应删除特定的哈希图。然后您可以使用Vec::retain，它会在保留顺序的同时有条件地删除元素。不幸的是，这个函数没有将索引传递给闭包，所以我们必须创建一个解决方法（playground）：

let mut to_delete = vec![false; v.len()];
for (i, set_a) in v.iter().enumerate().rev() {
    for set_b in &v[..i] {
        if set_a.is_subset(&set_b) {
            to_delete[i] = true;
        }
    }
}

{
    // This assumes that retain checks the elements in the order.
    let mut i = 0;
    v.retain(|_| {
        let ret = !to_delete[i];
        i += 1;
        ret
    });
}

如果你的 hashmap 有一个在正常情况下永远不会出现的特殊值，你可以使用它来将 hashmap 标记为“删除”，然后在retain 中检查该条件（这需要将外部循环从虽然基于迭代器到基于范围）。

---

旁注（如果HashSet<u8> 不仅仅是一个玩具示例）：存储和比较小整数集的更有效方法是使用bitset。