Question

给定一组间隔（表示范围的整数对），我想找到所有间隔包含关系。我使用它的应用程序是删除信息提取系统中的冗余项目;如果我检测到区间[2,3]和[2,6]都是地址（可能第一个是街道地址但第二个包含邮政编码之前的所有内容），则给出一组提取的段，一些被归类为地址，那我只需要包含间隔。

我只能在网上找到一些关于这个问题的提及，并且我使用稀疏笔记here在Java中实现以下内容：

import static java.util.Collections.reverseOrder;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

public class IntervalContainmentDetector {
    private static class Interval {
        private final int left;
        private final int right;
        public Interval(int l, int r) {
            left = l;
            right = r;
        }
        public int getLeft() {
            return left;
        }
        public int getRight() {
            return right;
        }
        public String toString() {
            return "[" + left + "," + right + "]";
        }
    }

    public static void main(String[] args) {
        @SuppressWarnings("serial")
        List<Interval> intervals = new LinkedList<Interval>() {
            {
                add(new Interval(0, 4));
                add(new Interval(2, 3));
                add(new Interval(0, 6));
                add(new Interval(4, 9));
                add(new Interval(4, 9));
                add(new Interval(4, 5));
                add(new Interval(3, 4));
                add(new Interval(6, 9));
                add(new Interval(4, 4));
                add(new Interval(5, 7));
                add(new Interval(1, 2));
            }
        };

        findContainments(intervals);
    }

    // sort ascending on left, descending on right;
    private static final Comparator<Interval> INTERVAL_SORTER = Comparator
            .comparing(Interval::getLeft).thenComparing(
                    interval -> interval.getRight(), reverseOrder());

    private static void findContainments(List<Interval> intervals) {
        List<Interval> sorted = intervals.stream().sorted(INTERVAL_SORTER)
                .collect(Collectors.toList());
        System.out.println("sorted: " + sorted);
        while (!sorted.isEmpty()) {
            LinkedList<Interval> containers = new LinkedList<>();
            containers.add(sorted.remove(0));
            recurse(sorted, containers);
        }
    }

    private static void recurse(List<Interval> remainingList,
            LinkedList<Interval> inList) {
        if (remainingList.isEmpty())
            return;
        while (!remainingList.isEmpty()) {
            Interval thisElement = remainingList.get(0);
            if (thisElement.getRight() <= inList.getLast().getRight()) {
                printContainment(inList, thisElement);
                remainingList.remove(0);
                inList.addLast(thisElement);
                recurse(remainingList, inList);
                inList.removeLast();
            } else
                return;
        }
    }

    private static void printContainment(List<Interval> containerList,
            Interval containedElement) {
        System.out.println(containedElement + " is contained by "
                + containerList);
    }
}

＆＃34;排序＆＃34; print是确定排序是否正常工作。上面的代码打印出以下内容：

sorted: [[0,6], [0,4], [1,2], [2,3], [3,4], [4,9], [4,9], [4,5], [4,4], [5,7], [6,9]]
[0,4] is contained by [[0,6]]
[1,2] is contained by [[0,6], [0,4]]
[2,3] is contained by [[0,6], [0,4]]
[3,4] is contained by [[0,6], [0,4]]
[4,9] is contained by [[4,9]]
[4,5] is contained by [[4,9], [4,9]]
[4,4] is contained by [[4,9], [4,9], [4,5]]
[5,7] is contained by [[4,9], [4,9]]
[6,9] is contained by [[4,9], [4,9]]

它错过[4,5]包含在[0,6]中;如果我删除两个[4,9]对，那么算法可以正常工作。

我不确定如何更新算法以便在这种情况下正常工作（其中非包含间隔包含一个包含的间隔，有效地阻止了被发现的关系）。我现在意识到我在上面提到的幻灯片（以及此other class site）中看到的问题陈述是列出任何其他区间内包含的区间，而不是列出所有包含关系。

如何更新此算法以正确查找所有间隔包含？

Answer 1

刚刚找到时间阅读你的算法基础。这是一个真正的O（n * log（n））。但是，它只是试图确定当前间隔包含在任何前一个间隔中（“......包含在某个其他间隔中。”）。

你在尝试的是不同的。您打算列出所有包含关系。这不包括在原始算法中，这就是杀死log（n）并导致O（n ^ 2）复杂度的原因。

您将识别算法上的注释，只是跟踪遇到的“最近端点”。没有跟踪早期的间隔。

目标的减少使得复杂性降低的算法成为可能。

获取所有包含会强制您处理间隔的部分排序。（这是导致您的算法无法检测到某些包含的原因。）原始算法利用转换为间隔的总排序来获得“某些包含”属性。

对于精确遏制，您需要遵守自然的偏序，最后进行完整的n *（n-1）比较。或者，您可以利用有关要检查的间隔之间关系的知识，但这与首先运行算法的需要相矛盾。所以我怀疑你会比O（n ^ 2）更好地获得所有的遏制。

Answer 2

试试这个：

Map<Interval, List<Interval>> mapContainments = new HashMap<>();

for(Interval interval : listIntervals) {
    List<Interval> containments = listIntervals.stream()
        .filter(i -> i != interval 
             && i.getLeft() <= interval.getLeft() 
             && i.getRight() >= interval.getRight())
        .collect(Collectors.toList());

    mapContainments.put(interval, containments);
}

mapContainers将包含每个时间间隔的所有包含。

查找所有间隔包含

2 个答案: