public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
StringTokenizer st;
t = Integer.parseInt(br.readLine());
while (t-- > 0) {
st = new StringTokenizer(br.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
S = Integer.parseInt(st.nextToken());
T = Integer.parseInt(st.nextToken());
// build graph
AdjList = new Vector<Vector<IntegerPair>>();
for (i = 0; i < n; i++) AdjList.add(new Vector<IntegerPair>());
while (m-- > 0) {
st = new StringTokenizer(br.readLine());
a = Integer.parseInt(st.nextToken());
b = Integer.parseInt(st.nextToken());
w = Integer.parseInt(st.nextToken());
AdjList.get(a).add(new IntegerPair(b, w)); // bidirectional
AdjList.get(b).add(new IntegerPair(a, w));
}
// SPFA from source S
// initially, only S has dist = 0 and in the queue
Vector<Integer> dist = new Vector<Integer>();
for (i = 0; i < n; i++) dist.add(INF);
dist.set(S, 0);
Queue<Integer> q = new LinkedList<Integer>();
q.offer(S);
Vector<Boolean> in_queue = new Vector<Boolean>();
for (i = 0; i < n; i++) in_queue.add(false);
in_queue.set(S, true);
while (!q.isEmpty()) {
int u = q.peek();
q.poll();
in_queue.set(u, false);
for (j = 0; j < AdjList.get(u).size(); j++) { // all outgoing edges from u
int v = AdjList.get(u).get(j).first(), weight_u_v = AdjList.get(u).get(j).second();
if (dist.get(u) + weight_u_v < dist.get(v)) { // if can relax
dist.set(v, dist.get(u) + weight_u_v); // relax
if (!in_queue.get(v)) { // add to the queue only if it's not in the queue
q.offer(v);
in_queue.set(v, true);
}
}
}
}
pr.printf("Case #%d: ", caseNo++);
if (dist.get(T) != INF) pr.printf("%d\n", dist.get(T));
else pr.printf("unreachable\n");
}
pr.close();
}
public void connect(TreeLinkNode root) {
if (root == null) return;
Queue<TreeLinkNode> queue = new LinkedList<TreeLinkNode>();
Queue<Integer> depth = new LinkedList<Integer>();
depth.add(1);
queue.add(root);
while (!queue.isEmpty()) {
TreeLinkNode parent = queue.poll();
Integer parDep = depth.poll();
if (parent.left != null) {
queue.add(parent.left);
depth.add(parDep + 1);
}
if (parent.right != null) {
queue.add(parent.right);
depth.add(parDep + 1);
}
// 还是广度搜索；
if (!queue.isEmpty()) {
TreeLinkNode next = queue.peek();
Integer nextDep = depth.peek();
if (nextDep != parDep) parent.next = null;
else parent.next = next;
} else parent.next = null;
}
}
protected void onUpdateData(int reason) {
publishUpdate(
new ExtensionData()
.visible(true)
.icon(R.drawable.ic_extension_example)
.status("Rss")
.expandedTitle(
(feedqueue.isEmpty()) ? "Error grabbing feeds" : feedqueue.peek().getTitle())
.expandedBody(
(feedqueue.isEmpty()) ? "Error grabbing feeds" : feedqueue.peek().getDescription())
.clickIntent(
new Intent(
Intent.ACTION_VIEW,
Uri.parse(
(feedqueue.isEmpty())
? "Error grabbing feeds"
: feedqueue.peek().getLink().toString()))));
if ((new java.util.Date()).getTime() - lastUpdate > 3600000) updateFeeds();
else if (!feedqueue.isEmpty()) {
Log.d("swiggins", "Displaying: " + feedqueue.peek().getTitle());
feedqueue.poll();
Log.d("swiggins", "Up next: " + feedqueue.peek().getTitle());
} else onInitialize(true);
}
/**
* This method is used to embed syntaxes associated with UDT attribute notations to a queue of
* string tokens extracted from a UDT parameter.
*
* @param tokens Queue of string tokens
* @param syntaxQueue Syntax embedded tokens
* @param isIndex Flag to determine whether a particular string token is an inidex or a column
* name
*/
public static void getSyntaxEmbeddedQueue(
Queue<String> tokens, Queue<String> syntaxQueue, boolean isIndex) {
if (!tokens.isEmpty()) {
if ("[".equals(tokens.peek())) {
isIndex = true;
tokens.poll();
syntaxQueue.add("INEDX_START");
syntaxQueue.add(tokens.poll());
} else if ("]".equals(tokens.peek())) {
isIndex = false;
tokens.poll();
syntaxQueue.add("INDEX_END");
} else if (".".equals(tokens.peek())) {
tokens.poll();
syntaxQueue.add("DOT");
syntaxQueue.add("COLUMN");
syntaxQueue.add(tokens.poll());
} else {
if (isIndex) {
syntaxQueue.add("INDEX");
syntaxQueue.add(tokens.poll());
} else {
syntaxQueue.add("COLUMN");
syntaxQueue.add(tokens.poll());
}
}
getSyntaxEmbeddedQueue(tokens, syntaxQueue, isIndex);
}
}
// Minimize the distance in k sorted arrays
public static int p15(int[][] arrs) {
Queue<P15Obj> q = new PriorityQueue<P15Obj>();
int max = Integer.MIN_VALUE;
for (int i = 0; i < arrs.length; i++) {
if (arrs[i].length > 0) {
q.add(new P15Obj(i, 0, arrs[i][0]));
if (max < arrs[i][0]) {
max = arrs[i][0];
}
} else {
return -1;
}
}
int minDist = Integer.MAX_VALUE;
do {
P15Obj min = q.remove();
minDist = Math.min(max - min.val, minDist);
int newVal = arrs[min.i][min.j + 1];
if (newVal > max) max = newVal;
q.add(new P15Obj(min.i, min.j + 1, newVal));
} while (q.peek().j < arrs[q.peek().i].length - 1);
return minDist;
}
/** This is synchronized to ensure that we process the queue serially. */
private synchronized void complete(String message) {
// This is a weird problem with writing stuff while idling. Need to investigate it more, but
// for now just ignore it.
if (MESSAGE_COULDNT_BE_FETCHED_REGEX.matcher(message).matches()) {
log.warn(
"Some messages in the batch could not be fetched for {}\n"
+ "---cmd---\n{}\n---wire---\n{}\n---end---\n",
new Object[] {config.getUsername(), getCommandTrace(), getWireTrace()});
errorStack.push(new Error(completions.peek(), message, wireTrace.list()));
throw new RuntimeException(
"Some messages in the batch could not be fetched for user " + config.getUsername());
}
CommandCompletion completion = completions.peek();
if (completion == null) {
if ("+ idling".equalsIgnoreCase(message)) {
synchronized (idleMutex) {
idler.idleStart();
log.trace("IDLE entered.");
idleAcknowledged.set(true);
}
} else {
log.error("Could not find the completion for message {} (Was it ever issued?)", message);
errorStack.push(new Error(null, "No completion found!", wireTrace.list()));
}
return;
}
if (completion.complete(message)) {
completions.poll();
}
}
/**
* 线程的主体方法
*
* @see java.lang.Thread#run()
*/
public void run() { // 线程的主体方法
while (conRun) {
try {
Thread.sleep(1000); // 线程休眠1秒
Queue<Object[]> queue = localPanel.queue; // 获取本地面板的队列对象
queueValues = queue.peek(); // 获取队列首的对象
if (queueValues == null) { // 如果该对象为空
continue; // 进行下一次循环
}
File file = (File) queueValues[0]; // 获取队列中的本队文件对象
FtpFile ftpFile = (FtpFile) queueValues[1]; // 获取队列中的FTP文件对象
if (file != null) {
selPath = file.getParent();
copyFile(file, ftpFile); // 调用递归方法上传文件
FtpPanel ftpPanel = localPanel.frame.getFtpPanel();
ftpPanel.refreshCurrentFolder(); // 刷新FTP面板中的资源
}
Object[] args = queue.peek();
// 判断队列顶是否为处理的上一个任务。
if (queueValues == null || args == null || !queueValues[0].equals(args[0])) {
continue;
}
queue.remove(); // 移除队列首元素
} catch (Exception e) {
e.printStackTrace();
}
}
}
private static double median() {
if (count % 2 != 0) {
return Double.valueOf(maxHeap.peek());
} else {
return (maxHeap.peek() + minHeap.peek()) / 2.0;
}
}
private static List<Integer> buildSkyline(Map<Integer, List<Building>> city) {
Queue<Building> heights = new PriorityQueue<Building>();
boolean[] active = new boolean[MAX_B + 1];
List<Integer> skyline = new LinkedList<Integer>();
int currHeight = 0;
for (Integer p : city.keySet()) {
for (Building b : city.get(p)) {
if (p.intValue() == b.left) {
heights.offer(b);
active[b.idx] = true;
} else {
active[b.idx] = false;
if (b.height == heights.peek().height) {
while (!heights.isEmpty() && !active[heights.peek().idx]) {
heights.poll();
}
}
}
}
if (heights.isEmpty()) {
skyline.add(p);
skyline.add(0);
currHeight = 0;
} else if (currHeight != heights.peek().height) {
skyline.add(p);
skyline.add(heights.peek().height);
currHeight = heights.peek().height;
}
// System.out.printf("Point %d. Heights: %s; Skyline: %s\n",
// p, heights, skyline);
}
return skyline;
}
public int completed(R request) {
assert request.equals(requests.peek());
requests.poll();
int remaining = requests.size();
if (remaining != 0) coordinator.send(requests.peek());
return remaining;
}
public boolean eventHappened(int time) {
if (eventQueue.peek() != null) {
if (eventQueue.peek().getTimeStamp() == time) {
return true;
}
}
return false;
}
public void update() {
if (!tasks.isEmpty() && tasks.peek().time < (int) (System.currentTimeMillis() / 1000)) {
Task task = tasks.peek();
try {
if (task instanceof UpgradingFieldTask) {
connection.upgradingField(((UpgradingFieldTask) task).idField);
} else if (task instanceof UpgradingBuildingTask) {
connection.upgradingBuilding(((UpgradingBuildingTask) task).idField);
}
} catch (LoadHttpPageException ex) {
Logger.info("Can't load page");
return;
} catch (LoginException ex) {
Logger.info("Can't login again. Was account information change?");
return;
} catch (UpgradingAvailableException ex) {
if (buildingProductions != null && buildingProductions.length != 0) {
int time = buildingProductions[buildingProductions.length - 1];
task.time = buildingProductionsLastUpdate + time + 10;
Logger.info("Already upgrading filed. Wait " + time + " sec");
} else {
UpgradingFieldPage page = ex.getUpgradingFieldPage();
if (page.requiredResourses != null && resources != null && productions != null) {
int time = 0;
for (int i = 0; i < 4; i++) {
int resorceTime =
(int)
Math.floor(
(page.requiredResourses[i] - resources[i])
/ (double) productions[i]
* 3600)
+ resourcesLastUpdate;
if (time < resorceTime) {
time = resorceTime;
}
}
Logger.info("Wait resource to " + time + " ");
task.time = time + 60;
} else {
task.time = task.time + 300;
}
}
return;
}
tasks.poll();
}
}
public void testConsumingIterable_queue_removesFromQueue() {
Queue<Integer> queue = Lists.newLinkedList(asList(5, 14));
Iterator<Integer> consumingIterator = Iterables.consumingIterable(queue).iterator();
assertEquals(5, queue.peek().intValue());
assertEquals(5, consumingIterator.next().intValue());
assertEquals(14, queue.peek().intValue());
assertTrue(consumingIterator.hasNext());
assertTrue(queue.isEmpty());
}
public Map<Field, Object> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
Map<Field, Object> pass = new HashMap<Field, Object>();
for (Entry<Field, Queue<? extends Object>> entry : queues.entrySet()) {
final Field field = entry.getKey();
final Queue<? extends Object> queue = entry.getValue();
pass.put(field, queue.peek());
}
for (Entry<Field, Queue<? extends Object>> entry : queues.entrySet()) {
final Field field = entry.getKey();
final Queue<? extends Object> queue = entry.getValue();
queue.poll();
if (queue.isEmpty() && hasNext()) {
List<? extends Object> parameter = parameters.get(field);
queues.put(field, new LinkedList<Object>(parameter));
} else {
break;
}
}
return pass;
}
public static void connect(TreeLinkNode root) {
if (root == null) return;
Queue<TreeLinkNode> q = new LinkedList<>();
root.next = null;
q.add(root);
q.add(null);
while (!q.isEmpty()) {
TreeLinkNode n = q.poll();
if (n != null) {
n.next = q.peek();
q.add(n.left);
q.add(n.right);
if (q.peek() == null) q.add(null);
}
}
}
public static int nextImportantEvent(
Queue<OTH> othQueue, List<Instance> instanceList, CPUList cpuList) {
int nextImportantTime = Integer.MAX_VALUE;
int nextCpuTime;
int nextOthTime;
int nextNewTime;
if (othQueue.isEmpty()) {
nextOthTime = Integer.MAX_VALUE;
} else {
nextOthTime = othQueue.peek().getExitTime();
}
nextCpuTime = cpuList.getNextFinishTime();
if (instanceList.isEmpty()) {
nextNewTime = Integer.MAX_VALUE;
} else {
nextNewTime = instanceList.get(0).getStartTime();
}
nextImportantTime = Math.min(nextOthTime, nextCpuTime);
nextImportantTime = Math.min(nextImportantTime, nextNewTime);
// System.out.println("\n################## NEXT IMPORTANT TIME: " + nextImportantTime);
return nextImportantTime;
}
public void connect(TreeLinkNode root) {
if (root == null) {
return;
}
Queue<TreeLinkNode> queue = new LinkedList<TreeLinkNode>();
queue.offer(root);
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
root = queue.poll();
if (i == size - 1) {
root.next = null;
} else {
root.next = queue.peek();
}
if (root.left != null) {
queue.offer(root.left);
}
if (root.right != null) {
queue.offer(root.right);
}
}
}
}
protected void handleMessageData(byte[] aData) {
// grab last fragment, use if not complete
WebSocketFragment fragment = pendingFragments.peek();
if (fragment == null || fragment.isValid()) {
// assign web socket fragment since the last one was complete
fragment = new WebSocketFragment(aData);
pendingFragments.offer(fragment);
} else if (fragment != null) {
fragment.appendFragment(aData);
if (fragment.canBeParsed()) {
fragment.parseContent();
}
}
// if we have a complete fragment, handle it
if (fragment.isValid()) {
// handle complete fragment
handleCompleteFragment(fragment);
// if we have extra data, handle it
if (aData.length > fragment.getMessageLength()) {
handleMessageData(
WebSocketUtil.copySubArray(
aData, fragment.getMessageLength(), aData.length - fragment.getMessageLength()));
}
}
}
public static int checkTimes(
Queue<OTH> othQueue, List<Instance> instanceList, CPUList cpuList, int importantTime) {
int nextCpuTime;
int nextOthTime;
int nextNewTime;
if (othQueue.isEmpty()) {
nextOthTime = Integer.MAX_VALUE;
} else {
nextOthTime = othQueue.peek().getExitTime();
}
nextCpuTime = cpuList.getNextFinishTime();
if (instanceList.isEmpty()) {
nextNewTime = Integer.MAX_VALUE;
} else {
nextNewTime = instanceList.get(0).getStartTime();
}
if (importantTime == nextCpuTime) {
return 0;
}
if (importantTime == nextOthTime) {
return 1;
}
if (importantTime == nextNewTime) {
return 2;
}
return -1;
}
// Reads: value | '[' value1, value2, valueN ']'
private Object readValue(Queue<String> tokens) {
String token = tokens.poll();
if (!"[".equals(token)) {
return token;
} else {
List<Object> values = new ArrayList<Object>();
while (true) {
if ("]".equals(tokens.peek())) {
tokens.remove();
break;
}
Object value = readValue(tokens);
values.add(value);
String delimiter = tokens.poll();
if ("]".equals(delimiter)) {
break;
} else if (!",".equals(delimiter)) {
throw new IllegalArgumentException(String.format("Expected a comma after [%s]!", value));
}
}
return values;
}
}
@Override
public void bindView(View convertView, Context context, Cursor cursor) {
// Log.i(Constants.LOG_TAG, "in bind view " + cursor.getColumnCount());
if (convertView != null) {
ViewHolder holder = (ViewHolder) convertView.getTag();
Type type = new TypeToken<ArrayList<String>>() {}.getType();
ArrayList<String> finalOutputString = new Gson().fromJson(cursor.getString(1), type);
Log.d(Constants.LOG_TAG, " in bind view " + finalOutputString);
if (holder != null) {
if (mListTitle != null && !mListTitle.isEmpty()) {
holder.title.setText(mListTitle.peek());
mListTitle.remove();
}
if (finalOutputString != null && !finalOutputString.isEmpty()) {
if (finalOutputString.size() >= 1) {
holder.listItem1.setText(finalOutputString.get(0));
// Log.i(Constants.LOG_TAG, "in bind view pos 1 " + finalOutputString.get(0));
} else holder.listItem1.setText("");
if (finalOutputString.size() >= 2) {
holder.listItem2.setText(finalOutputString.get(1));
// Log.i(Constants.LOG_TAG, "in bind view pos 2 " + finalOutputString.get(1));
} else holder.listItem2.setText("");
if (finalOutputString.size() >= 3) {
// Log.i(Constants.LOG_TAG, "in bind view pos 3 " + finalOutputString.get(2));
holder.listItem3.setText(finalOutputString.get(2));
} else holder.listItem3.setText("");
}
} else return;
}
}
// A method used to tell set the time of how many ticks it takes to service the car
public static int setTime(Queue<Car> b, String name, int a) {
switch (b.size()) {
case 0: // if it is the first car to arrive it takes 3 turns to complete
if (a == 1) return 3;
if ((name == "N" || name == "S")
&& light
== true) // if there are no cars in a lane that is green then the car has to wait
// just one turn
return 1;
else if ((name == "E" || name == "W") && light == false) return 1;
else // the light is red for that lane and the car must wait 3 turns
return 3;
case 1:
// System.out.println("There is one car in the queue..so this is what b.peek().display does
// just below this line\n"+b.peek().display());
// the first if is to check if the car infront of it was the first car to arrive, if so,
// this is the socond car to arrive and mustwait 2 clicks.
if (b.peek().getTotalWait() == 3) return 2;
// if it was
// else if(b.peek().getTotalWait() == 2)
// return 1;
else return 1;
default:
return 1;
}
}
// 思路，还是一样借助两个队列来进行完成
public void connect(TreeLinkNode root) {
if (root == null) {
return;
}
Queue<TreeLinkNode> q1 = new LinkedList<TreeLinkNode>();
Queue<TreeLinkNode> q2 = new LinkedList<TreeLinkNode>();
q1.add(root);
root.next = null;
while (!(q1.isEmpty() && q2.isEmpty())) {
while (!q1.isEmpty()) {
TreeLinkNode node = q1.poll();
if (node.left != null) {
q2.add(node.left);
}
if (node.right != null) {
q2.add(node.right);
}
}
while (!q2.isEmpty()) {
TreeLinkNode node = q2.poll();
if (q2.isEmpty()) {
node.next = null;
} else {
node.next = q2.peek();
}
q1.add(node);
}
}
}
private void checkNextTick() {
// Check if there are more pending messages in the queue that can be processed next time around
if (!pending.isEmpty()
&& !sentCheck
&& !paused
&& (pendingResponse == null || pending.peek() instanceof HttpContent)) {
sentCheck = true;
vertx.runOnContext(
new VoidHandler() {
public void handle() {
sentCheck = false;
if (!paused) {
Object msg = pending.poll();
if (msg != null) {
processMessage(msg);
}
if (channelPaused && pending.isEmpty()) {
// Resume the actual channel
ServerConnection.super.doResume();
channelPaused = false;
}
}
}
});
}
}
@Override
public void onSendFinished(boolean success, File file, Object key) {
int status;
if (success) {
status = HistoryManager.STATUS_SEND_SUCCESS;
} else {
status = HistoryManager.STATUS_SEND_FAIL;
}
ContentValues values = new ContentValues();
values.put(MetaData.History.STATUS, status);
getContentResolver().update(getFileUri(key), values, null, null);
SendFileThread thread = mSendingFileThreadMap.get(key);
if (thread != null) {
thread.setSendFinished();
mSendingFileThreadMap.remove(key);
mSendQueue.remove();
}
thread = mSendQueue.peek();
if (thread != null) {
mExecutorService.execute(thread);
}
}
@Test
public void testConnectToServerEndpoint() throws Exception {
Tomcat tomcat = getTomcatInstance();
// Must have a real docBase - just use temp
Context ctx = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
ctx.addApplicationListener(
new ApplicationListener(TesterEchoServer.Config.class.getName(), false));
Tomcat.addServlet(ctx, "default", new DefaultServlet());
ctx.addServletMapping("/", "default");
tomcat.start();
WebSocketContainer wsContainer = ContainerProvider.getWebSocketContainer();
Session wsSession =
wsContainer.connectToServer(
TesterProgrammaticEndpoint.class,
ClientEndpointConfig.Builder.create().build(),
new URI("ws://localhost:" + getPort() + TesterEchoServer.Config.PATH_ASYNC));
CountDownLatch latch = new CountDownLatch(1);
BasicText handler = new BasicText(latch);
wsSession.addMessageHandler(handler);
wsSession.getBasicRemote().sendText(MESSAGE_STRING_1);
boolean latchResult = handler.getLatch().await(10, TimeUnit.SECONDS);
Assert.assertTrue(latchResult);
Queue<String> messages = handler.getMessages();
Assert.assertEquals(1, messages.size());
Assert.assertEquals(MESSAGE_STRING_1, messages.peek());
}
/* Given a binary tree, print its nodes in reverse level order */
private void reverseLevelOrder(Node node, TraversalCallback callback) {
Stack<Node> S = new Stack();
Queue<Node> Q = new LinkedList();
Q.add(node);
// Do something like normal level order traversal order. Following are the
// differences with normal level order traversal
// 1) Instead of printing a node, we push the node to stack
// 2) Right subtree is visited before left subtree
while (Q.isEmpty() == false) {
/* Dequeue node and make it root */
node = Q.peek();
Q.remove();
S.push(node);
/* Enqueue right child */
if (node.getRight() != null) {
Q.add(node.getRight()); // NOTE: RIGHT CHILD IS ENQUEUED BEFORE LEFT
}
/* Enqueue left child */
if (node.getLeft() != null) {
Q.add(node.getLeft());
}
}
// Now pop all items from stack one by one and print them
while (S.empty() == false) {
node = S.peek();
callback.execute(node);
S.pop();
}
}
private void downloadNext() {
if (downloadRunning) {
return;
}
DownloadJob downloadJob = queue.peek();
if (downloadJob != null) {
DownloadTask downloadTask =
new DownloadTask(
downloadJob,
new Handler() {
@Override
public void handleMessage(Message msg) {
final DownloadJob retryCandidate = queue.poll();
if (!retryCandidate.isSuccess() && retryCandidate.consumeRetry()) {
this.postDelayed(
new Runnable() {
@Override
public void run() {
queue.add(retryCandidate);
downloadNext();
}
},
3000);
}
downloadRunning = false;
downloadNext();
}
});
downloadRunning = true;
AsyncTaskUtils.execute(downloadTask);
}
}
public Session take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (active) {
Session first = queue.peek();
if (first == null) {
available.await();
} else {
long delay = getDelay(first, TimeUnit.NANOSECONDS);
if (delay > 0) {
available.awaitNanos(delay);
} else {
Session x = queue.poll();
assert x != null;
if (queue.size() != 0) {
available.signalAll(); // wake up other takers
}
return x;
}
}
}
throw new InterruptedException("Session queue is stopping");
} finally {
lock.unlock();
}
}
public static <T extends Comparable<T>> void merge(
Queue<T> left, Queue<T> right, Queue<T> output) {
T prevLeft = null;
T prevRight = null;
while ((left.size() > 0 && (prevLeft == null || prevLeft.compareTo(left.peek()) <= 0))
|| (right.size() > 0 && (prevRight == null || prevRight.compareTo(right.peek()) <= 0))) {
if (right.size() == 0 || (left.size() > 0 && left.peek().compareTo(right.peek()) <= 0)) {
prevLeft = left.poll();
output.add(prevLeft);
} else {
prevRight = right.poll();
output.add(prevRight);
}
}
}
