/** * Method to find the Euler Tour based on the Hierholzer's algorithm. * * @param g : Input graph for which the tour is to be found. * @return : Returns a list of edges that comprises of the Euler Tour. */ public static List<Edge> findEulerTour(Graph<Vertex> g) { Vertex start = g.verts.get(1); Stack<Edge> forward = new Stack<Edge>(); Stack<Edge> backtrack = new Stack<Edge>(); Edge e = getUnvisitedEdge(start); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } while (!(forward.isEmpty())) { e = forward.pop(); backtrack.push(e); e = getUnvisitedEdge(e.From); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } } List<Edge> path = new LinkedList<Edge>(); while (!backtrack.isEmpty()) { Edge edge = backtrack.pop(); path.add(edge); } return path; }
public boolean isValid(String s) { if (s == null || s.equals("()") || s.equals("{}") || s.equals("[]")) { return true; } char[] arr = s.toCharArray(); Stack<Character> stack = new Stack<Character>(); stack.push(arr[0]); for (int i = 1; i < s.length(); i++) { if ("({[".indexOf(arr[i] + "") != -1) { stack.push(arr[i]); continue; } if (stack.isEmpty()) { return false; } if (arr[i] == ')' && stack.peek() != '(') { return false; } if (arr[i] == '}' && stack.peek() != '{') { return false; } if (arr[i] == ']' && stack.peek() != '[') { return false; } stack.pop(); } if (!stack.isEmpty()) { return false; } return true; }
public boolean isValid(String s) { if (s == null || s.length() == 0) { return true; } if (s.length() % 2 != 0) { return false; } Stack<Character> stack = new Stack<Character>(); for (int i = 0; i < s.length(); i++) { Character cur = s.charAt(i); if (cur == '(' || cur == '[' || cur == '{') { stack.push(cur); continue; } if (cur == ')') { if (stack.isEmpty()) return false; if (stack.peek() != '(') { return false; } else stack.pop(); } if (cur == ']') { if (stack.isEmpty()) return false; if (stack.peek() != '[') { return false; } else stack.pop(); } if (cur == '}') { if (stack.isEmpty()) return false; if (stack.peek() != '{') { return false; } else stack.pop(); } } return stack.isEmpty(); }
@NotNull private static Collection<PsiLanguageInjectionHost> collectInjectionHosts( @NotNull PsiFile file, @NotNull TextRange range) { Stack<PsiElement> toProcess = new Stack<PsiElement>(); for (PsiElement e = file.findElementAt(range.getStartOffset()); e != null; e = e.getNextSibling()) { if (e.getTextRange().getStartOffset() >= range.getEndOffset()) { break; } toProcess.push(e); } if (toProcess.isEmpty()) { return Collections.emptySet(); } Set<PsiLanguageInjectionHost> result = null; while (!toProcess.isEmpty()) { PsiElement e = toProcess.pop(); if (e instanceof PsiLanguageInjectionHost) { if (result == null) { result = ContainerUtilRt.newHashSet(); } result.add((PsiLanguageInjectionHost) e); } else { for (PsiElement child = e.getFirstChild(); child != null; child = child.getNextSibling()) { if (e.getTextRange().getStartOffset() >= range.getEndOffset()) { break; } toProcess.push(child); } } } return result == null ? Collections.<PsiLanguageInjectionHost>emptySet() : result; }
public static boolean isBalanced(String s) { Stack<Character> stack = new Stack<Character>(); for (int i = 0; i < s.length(); ++i) { char c = s.charAt(i); if (c == '{' || c == '[' || c == '(') stack.push(c); else if (c == '}') { if (!stack.isEmpty() && stack.peek() == '{') { stack.pop(); } else return false; } else if (c == ']') { if (!stack.isEmpty() && stack.peek() == '[') { stack.pop(); } else return false; } else if (c == ')') { if (!stack.isEmpty() && stack.peek() == '(') { stack.pop(); } else return false; } else { } } return stack.isEmpty(); }
public int maximalRectangle(char[][] matrix) { if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0; int cLen = matrix[0].length; // column length int rLen = matrix.length; // row length // height array int[] h = new int[cLen + 1]; h[cLen] = 0; int max = 0; for (int row = 0; row < rLen; row++) { Stack<Integer> s = new Stack<Integer>(); for (int i = 0; i < cLen + 1; i++) { if (i < cLen) if (matrix[row][i] == '1') h[i] += 1; else h[i] = 0; if (s.isEmpty() || h[s.peek()] <= h[i]) s.push(i); else { while (!s.isEmpty() && h[i] < h[s.peek()]) { int top = s.pop(); int area = h[top] * (s.isEmpty() ? i : (i - s.peek() - 1)); if (area > max) max = area; } s.push(i); } } } return max; }
// Get the front element. public int peek() { if (stack2.isEmpty()) { while (!stack1.isEmpty()) { stack2.push(stack1.pop()); } } return stack2.peek(); }
// Removes the element from in front of queue. public void pop() { if (stack2.isEmpty()) { while (!stack1.isEmpty()) { stack2.push(stack1.pop()); } } stack2.pop(); }
// Get the front element. public int peek() { if (outStack.isEmpty()) { while (!inStack.isEmpty()) { int temp = inStack.pop(); outStack.push(temp); } } return outStack.peek(); }
// peek function private int peek() { if (isEmpty()) return Integer.MIN_VALUE; if (stack2.isEmpty()) { while (!stack1.isEmpty()) { stack2.push(stack1.pop()); } } return stack2.peek(); }
// Removes the element from in front of queue. public void pop() { if (outStack.isEmpty()) { while (!inStack.isEmpty()) { int temp = inStack.pop(); outStack.push(temp); } } outStack.pop(); }
public Stack(Stack<T> stack) { Stack<T> tmpStack = new Stack<T>(); while (!stack.isEmpty()) { tmpStack.push(stack.pop()); } while (!tmpStack.isEmpty()) { T item = tmpStack.pop(); push(item); stack.push(item); } }
// based on the insertion sort public static Stack sortStack(Stack s1) { Stack s2 = new Stack(); while (!s1.isEmpty()) { int temp = s1.pop(); while (!s2.isEmpty() && s2.peek() < temp) { s1.push(s2.pop()); } s2.push(temp); } return s2; }
@Override public ACTIONS act(StateObservation stateObs, ElapsedCpuTimer elapsedTimer) { float avgTime = 10; float worstTime = 10; float totalTime = 0; int numberOfIterations = 0; int limitExpansions = 1; // ArrayList<Node> queue = new ArrayList<Node>(); Stack<Node> st = new Stack<Node>(); Node currentNode = new Node(null, Types.ACTIONS.ACTION_NIL, stateObs); st.push(currentNode); ArrayList<Types.ACTIONS> possibleActions = stateObs.getAvailableActions(); while (!st.isEmpty() && elapsedTimer.remainingTimeMillis() > 2 * avgTime && elapsedTimer.remainingTimeMillis() > worstTime) { // while(!st.isEmpty()){ ElapsedCpuTimer methodTime = new ElapsedCpuTimer(); currentNode = st.pop(); if (currentNode.state.getGameWinner() == WINNER.PLAYER_WINS) { break; } if (currentNode.state.getGameWinner() == WINNER.PLAYER_LOSES) { continue; } if (deepFromRoot(currentNode) <= limitExpansions - 1) { possibleActions = currentNode.state.getAvailableActions(); for (int i = 0; i < possibleActions.size(); i++) { StateObservation newState = currentNode.state.copy(); newState.advance(possibleActions.get(i)); Node newNode = new Node(currentNode, possibleActions.get(i), newState); st.push(newNode); } } if (st.isEmpty()) { limitExpansions += 1; st.push(new Node(null, Types.ACTIONS.ACTION_NIL, stateObs)); } numberOfIterations += 1; totalTime += methodTime.elapsedMillis(); avgTime = totalTime / numberOfIterations; } // System.out.println(numberOfIterations); return currentNode.getAction(); }
@Test public void testPush() { // Stack stack = new Stack(5); Integer i = 0; stack.push(i); assertFalse("Stack size = 1", stack.isEmpty()); Stack<Double> stackDouble = new Stack<Double>(); Double f = 0.1; stackDouble.push(f); assertFalse("Stack size = 1", stackDouble.isEmpty()); }
@Test public void testEmpty() { Stack<String> testStack = new Stack<String>(); assertTrue(testStack.isEmpty()); String test = "Test"; testStack.push(test); assertFalse(testStack.isEmpty()); testStack.pop(); assertTrue(testStack.isEmpty()); }
/** * Solution idea: * * <p>When traverse the stack and move it to the sorted stack, we can use a variable to store the * minimum element and then push it to the top of the stack. */ public Stack sort(Stack stack) { Stack result = new Stack(); if (stack != null) { while (!stack.isEmpty()) { int item = stack.pop(); while (!result.isEmpty() && result.peek() < item) { stack.push(result.pop()); } result.push(item); } } return result; }
public static void main(String[] args) throws IOException { br = new BufferedReader(new InputStreamReader(System.in)); out = new PrintWriter(new OutputStreamWriter(System.out)); // br = new BufferedReader(new FileReader("in.txt")); // out = new PrintWriter(new FileWriter("out.txt")); N = readInt(); val = new int[N]; hi = new int[N]; lo = new int[N]; poss = new ArrayList<ArrayList<Integer>>(); intervals = new TreeSet<Interval>(); for (int i = 0; i < N; i++) val[i] = readInt(); for (int i = 0; i < 2 * N; i++) poss.add(new ArrayList<Integer>()); Stack<State> s = new Stack<State>(); // processing upper bound (first number less than the current number) for (int i = N - 1; i >= 0; i--) { while (!s.isEmpty() && val[i] < s.peek().val) s.pop(); if (s.isEmpty()) hi[val[i]] = N; else hi[val[i]] = s.peek().index; s.push(new State(val[i], i)); } s.clear(); // processing lower bound (last number greater than the current number) for (int i = 0; i < N; i++) { while (!s.isEmpty() && val[i] > s.peek().val) s.pop(); if (s.empty()) lo[val[i]] = -1; else lo[val[i]] = s.peek().index; s.push(new State(val[i], i)); } for (int i = 0; i < N; i++) { int diff = val[i] - i + N - 1; poss.get(diff).add(i); } for (int i = 0; i < 2 * N; i++) { sweep(poss.get(i)); } out.println(intervals.size()); for (Interval i : intervals) out.printf("%d %d\n", i.l + 1, i.r + 1); out.close(); }
/** * Get the ISchemaElement corresponding to this IDocumentElementNode * * @param node * @param extensionPoint the extension point of the schema, if <code>null</code> it will be * deduced * @return the ISchemaElement for <code>node</code> */ public static ISchemaElement getSchemaElement(IDocumentElementNode node, String extensionPoint) { if (extensionPoint == null) { IMonitorObject obj = getTopLevelParent(node); if (!(obj instanceof IMonitorExtension)) return null; extensionPoint = ((IMonitorExtension) obj).getPoint(); } ISchema schema = MDECore.getDefault().getSchemaRegistry().getSchema(extensionPoint); if (schema == null) return null; // Bug 213457 - look up elements based on the schema in which the parent is found if (schema.getIncludes().length == 0 || "extension".equals(node.getXMLTagName())) // $NON-NLS-1$ return schema.findElement(node.getXMLTagName()); // if element is not "extension" & has multiple sub-schemas, // Then search for the element in the same schema in which the parent element if found. Stack stack = new Stack(); while (node != null) { String tagName = node.getXMLTagName(); if ("extension".equals(tagName)) // $NON-NLS-1$ break; stack.push(node.getXMLTagName()); node = node.getParentNode(); } ISchemaElement element = null; while (!stack.isEmpty()) { element = schema.findElement((String) stack.pop()); if (element == null) return null; schema = element.getSchema(); } return element; }
@Test public void PushNull() { // Stack stack = new Stack(2); Integer i = null; stack.push(i); assertFalse("Stack size = 1", stack.isEmpty()); }
@Test public void testPushPop() { // Stack stack = new Stack(5); stack.push(0); stack.pop(); assertTrue("Stack is empty", stack.isEmpty()); }
/** * find a solution to the initial board (using the A* algorithm). Result will be stored in * searchNodeSolution queue; * * @param initial */ public Solver(Board initial) { SearchNode initSearchNd = new SearchNode(initial, null); initialBoard = initial; pq.insert(initSearchNd); // output System.out.println("======Original SearchBoard=========="); outputSN(initSearchNd); // find the Goal SearchNode while (!pq.min().board.isGoal()) { Stack<SearchNode> stackSNforNbrs = new Stack<SearchNode>(); System.out.println("======NextLevel SearchBoard=========="); // Insert all neighbors in the priority queue stackSNforNbrs = findNbrSearchNode(pq.delMin()); while (stackSNforNbrs.size() != 0) { pq.insert(stackSNforNbrs.pop()); } } // Trace back the search node SearchNode snInSolution = pq.min(); Stack<SearchNode> stacksolution = new Stack<SearchNode>(); while (snInSolution.prevNode != null) { stacksolution.push(snInSolution); snInSolution = snInSolution.prevNode; } stacksolution.push(initSearchNd); // Make it reverse order while (!stacksolution.isEmpty()) searchNodeSolution.enqueue(stacksolution.pop()); }
public static void createNgramsFromFolder( File input_folder, File output_folder, int ngram_value) { Stack<File> stack = new Stack<File>(); stack.push(input_folder); while (!stack.isEmpty()) { File child = stack.pop(); if (child.isDirectory()) { for (File f : child.listFiles()) stack.push(f); } else if (child.isFile()) { try { System.out.println("Processing: " + child.getAbsolutePath()); FileReader fr = new FileReader(child.getAbsolutePath()); FileWriter outputFile = new FileWriter(output_folder + "/file" + file_no); BufferedReader br = new BufferedReader(fr); String readline = ""; while ((readline = br.readLine()) != null) { String[] words = readline.split("\\s+"); for (int i = 0; i < words.length - ngram_value + 1; i++) { String ngram = ""; for (int j = 0; j < ngram_value; j++) ngram = ngram + " " + words[i + j]; outputFile.write(ngram + "\n"); } } file_no++; outputFile.close(); br.close(); fr.close(); } catch (Exception e) { System.out.println("File not found:" + e); } } } }
public XNStackFrame getCurrentStackFrame() { if (!callStack.isEmpty()) { return callStack.peek(); } else { return null; } }
public XNResponder getCurrentResponder() { if (!responderStack.isEmpty()) { return responderStack.peek(); } else { return null; } }
private CellSet seedFillOld(Cell seed, char newChar) { CellSet cellsFilled = new CellSet(); char oldChar = get(seed); if (oldChar == newChar) return cellsFilled; if (isOutOfBounds(seed)) return cellsFilled; Stack<Cell> stack = new Stack<Cell>(); stack.push(seed); while (!stack.isEmpty()) { Cell cell = stack.pop(); set(cell, newChar); cellsFilled.add(cell); Cell nCell = cell.getNorth(); Cell sCell = cell.getSouth(); Cell eCell = cell.getEast(); Cell wCell = cell.getWest(); if (get(nCell) == oldChar) stack.push(nCell); if (get(sCell) == oldChar) stack.push(sCell); if (get(eCell) == oldChar) stack.push(eCell); if (get(wCell) == oldChar) stack.push(wCell); } return cellsFilled; }
@Override public List<String> getPaths(int catId) { int depth = getDepth(catId); List<Stack<Integer>> idPaths = new LinkedList<>(); Stack<Integer> stack = new Stack<>(); stack.add(catId); idPaths.add(stack); for (int i = depth; i > 1; i--) { idPaths = walkUp(idPaths); } // idPaths里面的每条Path都是存放在栈中的以id表示的路径,下面转换为字符串形式 List<String> list = new LinkedList<>(); for (Stack<Integer> path : idPaths) { StringBuilder sb = new StringBuilder(); while (!path.isEmpty()) { int id = path.pop(); String name = getNameById(id); int conceptCount = getConceptCount(id); sb.append("/").append(name + "(" + conceptCount + ")"); } list.add(sb.toString()); } return list; }
/** main method for solver. solves a sudoku puzzle */ public static void main(String[] args) { Stack<GameBoard> stack = new LinkedList<GameBoard>(); // intializes stack GameBoard board = new GameBoard(); // creates the game board stack.push(board); boolean solved = false; while (solved == false) { if (stack.isEmpty()) // if stack is empty the board is unsolvable System.out.println("board is unsolvable"); GameBoard curr = stack.pop(); if (curr.solved()) { System.out.println(curr); solved = true; return; } int[] mostConstrained = curr .mostConstrained(); // array containing the row and column of the most constrined spot // on the board for (int i = 1; i < 10; i++) // checks what numbers can be placed at the most constrained spot { if (curr.canPlace(mostConstrained[0], mostConstrained[1], i)) { GameBoard temp = new GameBoard( curr); // calls the copy constructor and creates a copy of current game board temp.place(mostConstrained[0], mostConstrained[1], i); stack.push(temp); } } } }
public List<Interval> merge(List<Interval> intervals) { if (intervals == null) return null; Collections.sort(intervals, new IntervalComparator()); Stack<Interval> stack = new Stack<Interval>(); for (Interval i : intervals) { if (stack.isEmpty()) { stack.push(i); } else { Interval t = stack.peek(); if (hasOverlap(t, i)) { Interval newInterval = new Interval(t.start, Math.max(t.end, i.end)); stack.pop(); stack.push(newInterval); } else { stack.push(i); } } } int length = stack.size() - 1; Interval[] intervalArray = new Interval[stack.size()]; for (int i = length; i >= 0; i--) { intervalArray[i] = stack.pop(); } return Arrays.asList(intervalArray); }
public int largestRectangleArea(int[] height) { int n = height.length; Stack<Integer> stack = new Stack<Integer>(); int max = 0; for (int i = 0; i <= n; i++) { int curt = (i == n) ? -1 : height[i]; while (!stack.isEmpty() && curt < height[stack.peek()]) { int index = stack.pop(); int left = (stack.isEmpty()) ? -1 : stack.peek(); int right = i; max = Math.max(max, height[index] * (right - left - 1)); } stack.push(i); } return max; }