[Random Coding]Interval Related Questions

原创于 2013-11-11 11:29:52 发布 · 834 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

Interval 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种用于合并具有相同权重的相邻区间的算法。通过创建节点列表并对其进行排序，算法能够有效地跟踪权重的变化，并在权重发生变化时记录区间的开始和结束位置。最终，将连续且权重相同的区间进行合并，得到简化的区间列表。

对于每一个end point都生成了新的interval，所以最后一步要把相邻并且weight相同的interval合并。

本例中，res中依然存在可以合并的interval。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.PriorityQueue;

public class WeightedInterval {
	public static class Interval {
		int start;
		int end;
		int weight;

		Interval(int start, int end, int weight) {
			this.start = start;
			this.end = end;
			this.weight = weight;
		}
	}

	public ArrayList<Interval> solve(ArrayList<Interval> input) {
		ArrayList<Node> nodes = new ArrayList<Node>();
		for (int i = 0; i < input.size(); i++) {
			nodes.add(new Node(input.get(i).start, true, input.get(i).weight));
			nodes.add(new Node(input.get(i).end, false, input.get(i).weight));
		}
		Comparator<Node> comp = new Comparator<Node>() {
			public int compare(Node node1, Node node2) {
				if (node1.pos > node2.pos)
					return 1;
				else if (node1.pos == node2.pos) {
					if (node1.start)
						return -1;
					else if (node2.start)
						return 1;
					else
						return -1;
				} else
					return -1;
			}
		};
		Collections.sort(nodes, comp);
		Comparator<Integer> heap_comp = new Comparator<Integer>() {
			public int compare(Integer i1, Integer i2) {
				return i2 - i1;
			}
		};
		PriorityQueue<Integer> max_heap = new PriorityQueue<Integer>(5,
				heap_comp);
		ArrayList<Interval> res = new ArrayList<Interval>();
		int i = 0;
		int last_pos = -1;
		while (i < nodes.size()) {
			Node cur = nodes.get(i);
			if (last_pos == -1 && cur.start) {
				max_heap.add(cur.weight);
				last_pos = cur.pos;
				i++;
				continue;
			}
			if (cur.start) {
				if (cur.pos != last_pos) {
					res.add(new Interval(last_pos, cur.pos, max_heap.peek()));
					last_pos = cur.pos;
				}
				max_heap.add(cur.weight);
			} else { // cur.start = false
				if (cur.pos != last_pos) {
					res.add(new Interval(last_pos, cur.pos, max_heap.peek()));
					// need to delete weight before deciding last_pos
					max_heap.remove(cur.weight);
					if (max_heap.isEmpty())
						last_pos = -1;
					else
						last_pos = cur.pos;
				} else
					max_heap.remove(cur.weight);
			}
			i++;
		}
		ArrayList<Interval> final_res = new ArrayList<Interval>();
		if (res.size() != 0) {
			Interval cur = res.get(0);
			for (int j = 1; j < res.size(); j++) {
				Interval next = res.get(j);
				if (cur.end == next.start && cur.weight == next.weight)
					cur.end = next.end;
				else {
					final_res.add(cur);
					cur = next;
				}
			}
			final_res.add(cur);
		}
		return final_res;
	}

	public static class Node {
		int pos;
		boolean start;
		int weight;

		Node(int pos, boolean start, int weight) {
			this.pos = pos;
			this.start = start;
			this.weight = weight;
		}
	}

	public static void main(String[] args) {
		ArrayList<Interval> input = new ArrayList<Interval>();
		input.add(new Interval(0, 1, 14));
		input.add(new Interval(0, 5, 17));
		input.add(new Interval(3, 7, 12));
		WeightedInterval test = new WeightedInterval();
		test.solve(input);
	}
}