// Adds a number into the data structure.
public void addNum(int num) {
minheap.offer(num);
maxheap.offer(minheap.poll());
if (maxheap.size() > minheap.size()) {
minheap.offer(maxheap.poll());
}
}
// Adds a number into the data structure.
public void addNum(int num) {
max.offer(num);
min.offer(max.poll());
if (max.size() < min.size()) {
max.offer(min.poll());
}
}
public ListNode mergeKLists(ArrayList<ListNode> lists) {
if (lists == null || lists.isEmpty()) return null;
PriorityQueue<ListNode> heap =
new PriorityQueue<ListNode>(
lists.size(),
new Comparator<ListNode>() {
public int compare(ListNode o1, ListNode o2) {
return o1.data > o2.data ? 1 : (o1.data < o2.data ? -1 : 0);
}
});
for (ListNode node : lists) {
if (node != null) {
heap.add(node);
}
}
ListNode head = null, cur = null;
while (!heap.isEmpty()) {
if (head == null) {
head = heap.poll();
cur = head;
} else {
cur.next = heap.poll();
cur = cur.next;
}
if (cur.next != null) {
heap.add(cur.next);
}
}
return head;
}
public int[] firstK(int arr[], int k) {
int[] arrK = new int[k];
// max heap
PriorityQueue<Integer> heap =
new PriorityQueue<Integer>(
k,
new Comparator<Integer>() {
@Override
public int compare(Integer arg0, Integer arg1) {
return -arg0.compareTo(arg1);
}
});
for (int i = 0; i < arr.length; ++i) {
heap.add(arr[i]);
if (heap.size() > k) {
heap.poll();
}
}
int idx = 0;
while (!heap.isEmpty()) {
arrK[idx++] = heap.poll();
}
return arrK;
}
/** This methods extracts and stores all open right branches for future exploration */
protected void extractOpenRightBranches(SearchLoop searchLoop) {
// update parameters for restarts
if (nodesRecompute > 0) {
double ratio = nodesRecompute * 1.d / searchLoop.mMeasures.getNodeCount();
if (ratio > b && Z <= N) {
Z *= 2;
} else if (ratio < a && Z >= 2) {
Z /= 2;
}
}
limit += Z;
// then start the extraction of open right branches
int i = compareSubpath(searchLoop);
if (i < _unkopen.size()) {
extractOB(searchLoop, i);
}
// finally, get the best ORB to keep up the search
Open next = opens.poll();
while (next != null && !isValid(next.currentBound())) {
next = opens.poll();
}
if (next != null) {
copen = next.toArray();
// the decision in 0 is the last taken, then the array us reversed
ArrayUtils.reverse(copen);
current = 0;
nodesRecompute = searchLoop.mMeasures.getNodeCount() + copen.length;
} else {
// to be sure not to use the previous path
current = copen.length;
}
// then do the restart
searchLoop.restart();
}
protected List<InputSplit> combineSplits(
PriorityQueue<LuceneIndexInputSplit> splits,
long maxCombinedIndexSizePerSplit,
long maxNumIndexesPerSplit) {
// now take the one-split-per-index splits and combine them into multi-index-per-split splits
List<InputSplit> combinedSplits = Lists.newLinkedList();
LuceneIndexInputSplit currentSplit = splits.poll();
while (currentSplit != null) {
while (currentSplit.getLength() < maxCombinedIndexSizePerSplit) {
LuceneIndexInputSplit nextSplit = splits.peek();
if (nextSplit == null) {
break;
}
if (currentSplit.getLength() + nextSplit.getLength() > maxCombinedIndexSizePerSplit) {
break;
}
if (currentSplit.getIndexDirs().size() >= maxNumIndexesPerSplit) {
break;
}
currentSplit.combine(nextSplit);
splits.poll();
}
combinedSplits.add(currentSplit);
currentSplit = splits.poll();
}
return combinedSplits;
}
/**
* Advance the iterator. Should only be called if {@link #isValid()} returned true. Valid can
* only chance after calls to {@link #next()}.
*/
public void next() {
newKeyGroup = false;
newKVState = false;
final RocksIterator rocksIterator = currentSubIterator.getIterator();
rocksIterator.next();
byte[] oldKey = currentSubIterator.getCurrentKey();
if (rocksIterator.isValid()) {
currentSubIterator.currentKey = rocksIterator.key();
if (isDifferentKeyGroup(oldKey, currentSubIterator.getCurrentKey())) {
heap.offer(currentSubIterator);
currentSubIterator = heap.poll();
newKVState = currentSubIterator.getIterator() != rocksIterator;
detectNewKeyGroup(oldKey);
}
} else {
rocksIterator.close();
if (heap.isEmpty()) {
currentSubIterator = null;
valid = false;
} else {
currentSubIterator = heap.poll();
newKVState = true;
detectNewKeyGroup(oldKey);
}
}
}
@Override
public synchronized List<T> getTopK() {
Comparator<T> comparator =
new Comparator<T>() {
public int compare(T key1, T key2) {
return Longs.compare(counts.get(key1), counts.get(key2));
}
};
PriorityQueue<T> topK = new PriorityQueue<T>(k, comparator);
for (Map.Entry<T, Long> entry : counts.entrySet()) {
if (topK.size() < k) {
topK.offer(entry.getKey());
} else if (entry.getValue() > counts.get(topK.peek())) {
topK.offer(entry.getKey());
topK.poll();
}
}
LinkedList<T> sortedTopK = new LinkedList<T>();
while (!topK.isEmpty()) {
sortedTopK.addFirst(topK.poll());
}
return sortedTopK;
}
/**
* Get top N elements
*
* @param vec the vec to extract the top elements from
* @param N the number of elements to extract
* @return the indices and the sorted top N elements
*/
private static List<Double> getTopN(INDArray vec, int N) {
ArrayComparator comparator = new ArrayComparator();
PriorityQueue<Double[]> queue = new PriorityQueue<>(vec.rows(), comparator);
for (int j = 0; j < vec.length(); j++) {
final Double[] pair = new Double[] {vec.getDouble(j), (double) j};
if (queue.size() < N) {
queue.add(pair);
} else {
Double[] head = queue.peek();
if (comparator.compare(pair, head) > 0) {
queue.poll();
queue.add(pair);
}
}
}
List<Double> lowToHighSimLst = new ArrayList<>();
while (!queue.isEmpty()) {
double ind = queue.poll()[1];
lowToHighSimLst.add(ind);
}
return Lists.reverse(lowToHighSimLst);
}
public static void main(String args[]) throws IOException {
String text = "C:\\Users\\Roshan Rajan\\Desktop\\squaredance.txt";
String gender = "";
PriorityQueue<String> men = new PriorityQueue<String>();
PriorityQueue<String> women = new PriorityQueue<String>();
BufferedReader input = new BufferedReader(new FileReader(text));
String line = null;
while ((line = input.readLine()) != null) {
gender = line.substring(0, 1);
if (gender.equals("M")) men.add(line.substring(2));
else women.add(line.substring(2));
}
input.close();
while (!men.isEmpty() && !women.isEmpty()) {
System.out.println("The couples are ");
System.out.println(men.poll() + " is Dancing with " + women.poll());
}
if (men.isEmpty()) {
System.out.println(women.size() + " girls are Waiting to Dance");
System.out.println(women.peek() + " is the first one waiting");
}
if (women.isEmpty()) {
System.out.println(men.size() + " guys are Waiting to Dance");
System.out.println(men.peek() + " is the first one waiting");
}
}
private HeightEvent nextEvent() {
EdgeCollision ec;
for (; ; ) {
ec = faceEvents.poll();
if (ec == null) break;
// valid if we haven't seen it, and it's height is "greater" than
// the current skeleton height
if (!skel.seen.contains(ec) && ec.loc.z - skel.height > -0.001) break;
}
HeightEvent he = miscEvents.peek();
if (ec == null) {
return miscEvents.poll(); // might be null!
}
if (he == null) {
skel.seen.add(ec);
return ec; // might be null!
}
if (he.getHeight() <= ec.getHeight()) {
faceEvents.add(ec);
return miscEvents.poll(); // return he
} else {
skel.seen.add(ec);
return ec; // return ec
}
}
@Override
void solve(Set<? extends Job> jobs) {
Job[] sortedJobs = jobs.toArray(new Job[jobs.size()]);
Arrays.sort(sortedJobs, Job::compareArrivalTime);
processTime = totWT = 0;
long usefulTime = 0;
int jobCount = jobs.size();
PriorityQueue<Job> queue = new PriorityQueue<>(Job::compareBurstTime);
for (Job job : sortedJobs) {
if (job == null) {
jobCount--;
continue;
}
while (!queue.isEmpty() && processTime < job.getArrivalTime()) {
Job nextJob = queue.poll();
long arrivalTime = nextJob.getArrivalTime();
long burstTime = nextJob.getBurstTime();
if (processTime < nextJob.getArrivalTime()) {
processList.add(new RunningProcess("Idle", arrivalTime - processTime));
processTime = arrivalTime;
}
processList.add(new RunningProcess("P" + nextJob.getId(), burstTime));
usefulTime += burstTime;
totWT += processTime - arrivalTime;
processTime += burstTime;
}
queue.add(job);
}
while (!queue.isEmpty()) {
Job nextJob = queue.poll();
long arrivalTime = nextJob.getArrivalTime();
long burstTime = nextJob.getBurstTime();
if (processTime < nextJob.getArrivalTime()) {
processList.add(new RunningProcess("Idle", arrivalTime - processTime));
processTime = arrivalTime;
}
processList.add(new RunningProcess("P" + nextJob.getId(), burstTime));
usefulTime += burstTime;
totWT += processTime - arrivalTime;
processTime += burstTime;
}
totRT = totWT;
totTAT = totWT + usefulTime;
avgRT = avgWT = (double) totWT / (double) jobCount;
avgTAT = (double) totTAT / (double) jobCount;
utilization = usefulTime * 100.0 / processTime;
}
public Integer removeMedian() {
if (min.size() > max.size()) {
return max.poll();
} else if (min.size() > max.size()) {
return min.poll();
} else {
return ((max.poll() + min.poll()) / 2);
}
}
public static void main(String[] args) {
// Convert het woord naar chars
String woord = "bananen";
ArrayList<Character> chars = new ArrayList<>();
ArrayList<HuffKnoop> knopen = new ArrayList<>();
for (int i = 0; i < woord.length(); i++) {
chars.add(woord.charAt(i));
}
// 1. Frequentie van tekens
Set<Character> uniqueChars = new HashSet<>(chars);
for (char c : uniqueChars) {
knopen.add(new HuffKnoop(c, Collections.frequency(chars, c), null, null));
}
// 2. Sorteer de tekens op frequentie
PriorityQueue queue =
new PriorityQueue(
uniqueChars.size(),
new Comparator<HuffKnoop>() {
@Override
public int compare(HuffKnoop o1, HuffKnoop o2) {
return o1.frequentie - o2.frequentie;
}
});
for (HuffKnoop knoop : knopen) {
queue.add(knoop);
}
// 3. Maken van de huffman boom.
while (queue.size() > 1) {
HuffKnoop knoopLinks = (HuffKnoop) queue.poll();
HuffKnoop knoopRechts = (HuffKnoop) queue.poll();
queue.add(
new HuffKnoop(
'\0', knoopLinks.frequentie + knoopRechts.frequentie, knoopLinks, knoopRechts));
}
// 4. Aflezen van de codes
boom = (HuffKnoop) queue.poll();
generateCodes(boom, "");
Iterator it = codes.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pair = (Map.Entry) it.next();
System.out.println(pair.getKey() + " " + pair.getValue());
}
// 5. Coderen
String encodedMessage = encodeMessage(woord);
System.out.println(encodedMessage);
// 6. Decoderen
String decodedMessage = decodeMessage(encodedMessage);
System.out.println(decodedMessage);
}
@Test
public void test1p() {
PriorityQueue<Integer> queue = new PriorityQueue<>(4);
queue.add(1);
queue.add(2);
queue.add(3);
queue.add(4);
Assert.assertEquals(Integer.valueOf(1), queue.poll());
Assert.assertFalse(queue.poll().equals(4));
}
private void makeAFreeSpace() {
while ((activeCache.size() + passiveCache.size()) >= CACHE_SIZE && !passiveCache.isEmpty()) {
passiveCache.poll().getRenderedBitmap().recycle();
}
while ((activeCache.size() + passiveCache.size()) >= CACHE_SIZE && !activeCache.isEmpty()) {
activeCache.poll().getRenderedBitmap().recycle();
}
}
public Node huffman(PriorityQueue<Node> lst) {
int n = lst.size();
for (int i = 1; i < n; i++) {
Node x = lst.poll();
Node y = lst.poll();
Node z = new Node(x.freq + y.freq, x, y);
lst.add(z);
}
return lst.poll();
}
public PPath getShortestPath() {
PPath start = new PPath(null, src.x, src.y, getEstimatedDist(src.x, src.y));
pQueue.add(start);
PPath cur = pQueue.poll();
while (cur.value.x != dest.x || cur.value.y != dest.y) {
List<PPath> nextPaths = getNext(cur);
for (PPath nextPath : nextPaths) {
pQueue.add(nextPath);
}
cur = pQueue.poll();
}
return cur;
}
public static boolean canPartitionKarmarkarKarp(int[] baseArr) {
// create max heap
PriorityQueue<Integer> heap = new PriorityQueue<Integer>(baseArr.length, REVERSE_INT_CMP);
for (int value : baseArr) {
heap.add(value);
}
while (heap.size() > 1) {
int val1 = heap.poll();
int val2 = heap.poll();
heap.add(val1 - val2);
}
return heap.poll() == 0;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int row = sc.nextInt();
int column = sc.nextInt();
char[][] cityMap = new char[row][column]; // 获取城市的地图
for (int i = 0; i < row; i++) {
String str = sc.next();
for (int j = 0; j < column; j++) {
cityMap[i][j] = str.charAt(j);
}
}
// 获取可能的四种3*3的hi的布局
char[][] hi1 = new char[3][3];
char[][] hi2 = new char[3][3];
char[][] hi3 = new char[3][3];
char[][] hi4 = new char[3][3];
for (int i = 0; i < 3; i++) {
String str = sc.next();
for (int j = 0; j < 3; j++) {
char c = str.charAt(j);
hi1[i][j] = c;
hi2[2 - i][2 - j] = c;
hi3[2 - j][i] = c;
hi4[j][2 - i] = c;
}
}
PriorityQueue<Point> queen = new PriorityQueue<>();
for (int i = 1; i < row - 1; i++) {
for (int j = 1; j < column - 1; j++) {
if (isHere(hi1, cityMap, i, j)
|| isHere(hi2, cityMap, i, j)
|| isHere(hi3, cityMap, i, j)
|| isHere(hi4, cityMap, i, j)) {
queen.add(new Point(i, j));
}
}
}
Point p = queen.poll();
while (p != null) {
System.out.println((p.x + 1) + " " + (p.y + 1));
p = queen.poll();
}
}
public static void main(String[] args) {
PriorityQueue<Student> studenten = new PriorityQueue();
Student s1 = new Student(1, DateUtil.getDateInstance(1978, 3, 18));
Student s2 = new Student(2, DateUtil.getDateInstance(1962, 1, 24));
Student s3 = new Student(3, DateUtil.getDateInstance(1978, 5, 31));
studenten.add(s1);
studenten.add(s2);
studenten.add(s3);
System.out.println(studenten.poll().getGeboorteDatum());
System.out.println(studenten.poll().getGeboorteDatum());
System.out.println(studenten.poll().getGeboorteDatum());
}
protected TreeNode HuffTree(int[] count) {
PriorityQueue<TreeNode> q = new PriorityQueue<TreeNode>();
for (int i = 0; i < count.length; i++) {
if (count[i] > 0) {
q.add(new TreeNode(i, count[i]));
}
}
q.add(new TreeNode(PSEUDO_EOF, 1));
while (q.size() > 1) {
TreeNode a = q.poll();
TreeNode b = q.poll();
q.add(new TreeNode(-1, a.myWeight + b.myWeight, a, b));
}
return q.poll();
}
/** Implementation of dijkstra's algorithm using a binary heap. */
private void dijkstra(final PriorityQueue<Vertex> q) {
Vertex u, v;
while (!q.isEmpty()) {
u = q.poll(); // vertex with shortest distance (first iteration
// will return source)
// System.out.println("id is"+u.getId());
// System.out.println(u.getDist());
// System.out.println(u.getNeighborV().size());
// System.out.println(this.endNodeId)
if (u.getDist() == Double.MAX_VALUE)
break; // we can ignore u (and any other remaining vertices)
// since they are unreachable
// look at distances to each neighbor
for (Map.Entry<Vertex, Double> a : u.getNeighborV().entrySet()) {
v = a.getKey(); // the neighbor in this iteration
double alternateDist = u.getDist() + a.getValue();
if (alternateDist < v.getDist()) { // shorter path to neighbor
// found
// System.out.println("+++++");
q.remove(v);
v.setDist(alternateDist);
// System.out.println(v.getId());
// System.out.println(v.getDist());
v.setPrevious(u);
q.add(v);
// System.out.println(q.size());
}
}
}
}
public static List<Vertex> compute(Graph graph) {
List<Vertex> resultList = new LinkedList<Vertex>();
Vertex[] vertexes = graph.getVertexes();
List<EdgeFrom>[] edgesTo = graph.getEdgesTo();
double[] d = new double[vertexes.length];
Arrays.fill(d, Double.MAX_VALUE);
d[d.length - 1] = 0;
int[] path = new int[vertexes.length];
Arrays.fill(path, -1);
PriorityQueue<State> que = new PriorityQueue<State>();
que.add(new State(0, vertexes.length - 1));
while (!que.isEmpty()) {
State p = que.poll();
if (d[p.vertex] < p.cost) continue;
for (EdgeFrom edgeFrom : edgesTo[p.vertex]) {
if (d[edgeFrom.from] > d[p.vertex] + edgeFrom.weight) {
d[edgeFrom.from] = d[p.vertex] + edgeFrom.weight;
que.add(new State(d[edgeFrom.from], edgeFrom.from));
path[edgeFrom.from] = p.vertex;
}
}
}
for (int t = 0; t != -1; t = path[t]) {
resultList.add(vertexes[t]);
}
return resultList;
}
public static void main(String[] args) throws IOException {
int n = readInt();
int[] dogs = new int[n];
ArrayList<ArrayList<Integer>> adjlist = new ArrayList<ArrayList<Integer>>();
for (int x = 0; x < n; x++) {
dogs[x] = readInt();
adjlist.add(new ArrayList<Integer>());
}
int m = readInt();
for (int x = 0; x < m; x++) {
int a = readInt() - 1;
int b = readInt() - 1;
adjlist.get(a).add(b);
}
int time = readInt();
int[] bark = new int[n];
PriorityQueue<Dog> moves = new PriorityQueue<Dog>();
moves.add(new Dog(0, 0));
bark[0] = 0;
int[] total = new int[n];
while (!moves.isEmpty()) {
Dog curr = moves.poll();
if (curr.time > time) continue;
bark[curr.id] = 0;
total[curr.id]++;
for (int x = 0; x < adjlist.get(curr.id).size(); x++) {
int next = adjlist.get(curr.id).get(x);
if ((bark[next] != 0 && curr.time + dogs[next] > bark[next])) continue;
moves.remove(new Dog(next, curr.time + dogs[next]));
bark[next] = curr.time + dogs[next];
moves.offer(new Dog(next, curr.time + dogs[next]));
}
}
for (int x : total) System.out.println(x);
}
private void expandLandmarkTo() {
LandmarksToTravelTimeComparator comparator =
new LandmarksToTravelTimeComparator(this.nodeData, this.landmarkIdx);
PriorityQueue<Node> pendingNodes = new PriorityQueue<>(100, comparator);
LandmarksData role = (LandmarksData) this.nodeData.get(this.landmark);
role.setToLandmarkTravelTime(this.landmarkIdx, 0.0);
role.setFromLandmarkTravelTime(this.landmarkIdx, 0.0);
pendingNodes.add(this.landmark);
while (!pendingNodes.isEmpty()) {
Node node = pendingNodes.poll();
double toTravTime =
((LandmarksData) this.nodeData.get(node)).getToLandmarkTravelTime(this.landmarkIdx);
LandmarksData role2;
for (Link l : node.getInLinks().values()) {
Node n = l.getFromNode();
double linkTravTime = this.costFunction.getLinkMinimumTravelDisutility(l);
role2 = (LandmarksData) this.nodeData.get(n);
double totalTravelTime = toTravTime + linkTravTime;
if (role2.getToLandmarkTravelTime(this.landmarkIdx) > totalTravelTime) {
role2.setToLandmarkTravelTime(this.landmarkIdx, totalTravelTime);
pendingNodes.add(n);
}
}
}
}
public T receive() {
lock.lock();
try {
while (true) {
DelayedMessage message = queue.peek();
if (message == null && stopping) {
return null;
}
if (message == null) {
condition.await();
continue;
}
long now = timeProvider.getCurrentTime();
if (message.dispatchTime > now) {
condition.awaitUntil(new Date(message.dispatchTime));
} else {
queue.poll();
if (queue.isEmpty()) {
condition.signalAll();
}
return message.message;
}
}
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
} finally {
lock.unlock();
}
}
@Override
public CategoricalResults classify(DataPoint data) {
CategoricalResults cr = new CategoricalResults(predicting.getNumOfCategories());
// Use a priority que so that we always pick the two lowest value class labels, makes indexing
// into the oneVsOne array simple
PriorityQueue<Integer> options = new PriorityQueue<Integer>(predicting.getNumOfCategories());
for (int i = 0; i < cr.size(); i++) options.add(i);
CategoricalResults subRes;
int c1, c2;
// We will now loop through and repeatedly pick two combinations, and eliminate the loser, until
// there is one winer
while (options.size() > 1) {
c1 = options.poll();
c2 = options.poll();
subRes = oneVone[c1][c2 - c1 - 1].classify(data);
if (subRes.mostLikely() == 0) // c1 wins, c2 no longer a candidate
options.add(c1);
else // c2 wins, c1 no onger a candidate
options.add(c2);
}
cr.setProb(options.peek(), 1.0);
return cr;
}
private static PencilPosition findShortestRoute(int[][] maze) {
// all found solutions to the maze
PriorityQueue<PencilPosition> solutions =
new PriorityQueue<PencilPosition>(5, new PencilPositionComparator());
// bread-first search queue
Queue<PencilPosition> routes = new LinkedList<PencilPosition>();
// set of already visited positions
Set<PencilPosition> visitedPositions = new HashSet<PencilPosition>();
// add the starting positions, which is always (0,0)
routes.add(new PencilPosition(0, 0, false, null));
while (!routes.isEmpty()) {
PencilPosition position = routes.poll();
// if this is the destinations position then we've found a solution
if (0 == maze[position.row][position.column]) {
solutions.add(position);
continue;
}
// if we haven't already visited this position
if (!visitedPositions.contains(position)) {
routes.addAll(findPossibleRoutes(position, maze));
visitedPositions.add(position);
}
}
return solutions.poll();
}
public void PQOrdering() {
PriorityQueue<String> pq = new PriorityQueue<String>();
pq.add("5");
pq.add("3");
pq.add("1");
pq.add("2");
pq.add("4");
pq.add("6");
System.out.println("Unordered: " + pq); // Unordered: [1, 2, 3, 5, 4, 6]
Iterator<String> itr = pq.iterator();
System.out.print("Unordered Itr: ");
while (itr.hasNext()) {
System.out.print(itr.next() + ", "); // Unordered Itr: 1, 2, 3, 5, 4, 6,
}
System.out.println("");
System.out.print("Unordered Arrays: ");
Object[] obj = pq.toArray();
for (Object o : obj) {
System.out.print(o + ", "); // Unordered Arrays: 1, 2, 3, 5, 4, 6,
}
// To order a PQ
System.out.print("\nOrdered:");
while (!pq.isEmpty()) {
System.out.print(pq.poll() + ", "); // Ordered: 1, 2, 3, 4, 5, 6,
}
System.out.println("********************************************");
}