/**
* 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 int evalRPN(String[] strs) {
if (strs == null) return 0;
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < strs.length; i++) {
if (strs[i].equals("+")
|| strs[i].equals("-")
|| strs[i].equals("*")
|| strs[i].equals("/")) {
if (stack.size() < 2) return -1;
if (strs[i].equals("+")) {
stack.push(stack.pop() + stack.pop());
} else if (strs[i].equals("-")) {
stack.push(-stack.pop() + stack.pop());
} else if (strs[i].equals("*")) {
stack.push(stack.pop() * stack.pop());
} else if (strs[i].equals("/")) {
int a = stack.pop();
int b = stack.pop();
stack.push(b / a);
}
} else {
stack.push(Integer.parseInt(strs[i]));
}
}
return stack.pop();
}
public static boolean umpadi(Stack s) {
byte[] topElmt = ((Entry) s.peek()).getPart();
byte[] oldTopElmt = topElmt;
if (ByteMeth.endsWith(topElmt, Constant.umpadi)) {
// clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "umpadi");
s.pop();
s.push(new Entry(Constant.pati, Tag.ParticleSuffix));
s.push(new Entry(Constant.um, Tag.ThirdFutureNeuterSingularORRP));
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.umpadi.length);
if (ByteMeth.isEqual(topElmt, Constant.kEtk)) {
topElmt = ByteMeth.replace(topElmt, Constant.L, 2);
}
if (ByteMeth.endsWith(topElmt, Constant.var) || ByteMeth.endsWith(topElmt, Constant.thar)) {
topElmt = ByteMeth.replace(topElmt, Constant.A, Constant.ar.length);
}
if (ByteMeth.isEqual(topElmt, Constant.kaRk)
|| ByteMeth.isEqual(topElmt, Constant.viRk)
|| ByteMeth.isEqual(topElmt, Constant.n_iRk)) {
topElmt = ByteMeth.replace(topElmt, Constant.l, 2);
}
if (ByteMeth.isEqual(topElmt, Constant.sAk) || ByteMeth.isEqual(topElmt, Constant.pOk)) {
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - 1);
}
s.push(new Entry(topElmt, -1, oldTopElmt));
Sandhi.kk(s);
Sandhi.check(s);
return true;
}
return false;
}
public static boolean adverbial_Particle(Stack s) {
byte[] topElmt = ((Entry) s.peek()).getPart();
byte[] oldTopElmt = topElmt;
// kayil
if (ByteMeth.endsWith(topElmt, Constant.kayil)) {
// clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "kayil");
s.pop();
s.push(new Entry(Constant.kayil, Tag.ParticleSuffix)); // change
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.kayil.length);
s.push(new Entry(topElmt, -1, oldTopElmt));
Sandhi.k(s);
return true;
}
// poothu
if (ByteMeth.endsWith(topElmt, Constant.poothu)) {
// clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "poothu");
s.pop();
s.push(new Entry(Constant.poothu, Tag.ParticleSuffix)); // change
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.poothu.length);
s.push(new Entry(topElmt, -1, oldTopElmt));
Sandhi.k(s);
return true;
}
return false;
}
public static void main(String[] args)
throws fullQueueException, EmptyQueueException, FullStackException {
Main main = new Main();
System.out.println(
main.maximum(new Student("ali", 12), new Student("zohre", 10), new Student("ali", 18)));
Stack<Student> stack1 = new Stack<>();
stack1.push(new Student("ali", 15));
stack1.push(new Student("samira", 12));
System.out.println(stack1.pop());
Stack<Student> stack2 = new Stack<>();
stack2.push(new Student("ali", 15));
stack2.push(new Student("samira", 12));
System.out.println(stack2.pop());
boolean result = stack1.equals(new Stack<Double>());
System.out.println(result);
Queue<Student> queue = new Queue<>();
queue.push(new Student("ali", 15));
queue.push(new Student("samira", 12));
System.out.println(queue.pop());
}
public void printSolution() {
String currState = "www0bbb";
File file = new File("solution_slidingtile_dfs.txt");
try {
FileWriter fw = new FileWriter(file);
path.push(currState);
while (parentMap.get(currState) != null) {
// System.out.println("inside while, parentMap.get(currState)!=null");
path.push(parentMap.get(currState));
currState = parentMap.get(currState);
}
System.out.println("Solution path:");
while (!path.empty()) {
// System.out.println("inside while, stack not empty");
// System.out.println(path.pop());
fw.write(path.pop());
fw.write("\n");
}
fw.close();
} catch (IOException ie) {
ie.printStackTrace();
} finally {
}
}
@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;
}
private void dfs(Digraph G ,int v){
onStack[v] = true ;
marked[v] = true ;
for(int w:G.adj(v))
if(this.hasCycle()) {
}
if(!marked[v]){
edgeTo[w] = v;
dfs(G,w);
}
else{
if(onStack[w]){
cycle = new Stack<Integer>();
for(int x = v; x!=w;x =edgeTo[x]) cycle.push(x);
cycle.push(w);
cycle.push(v);
}
}
onStack[v] = false;
}
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);
}
}
}
}
/**
* Returns type converted to index type if needed. A index type variable in java splitter file has
* type "int" or "int[]" instead of "long" or "long[]". This is needed if the variable or the an
* element of the variable is used as an index to an array. This method converts the type of the
* variable to "int_index" or "index[]" if it is used as an index to an array or an element of it
* is used as an index to an array.
*
* @param type the original type of the variable.
* @param name the name of the variable.
* @param varInfo the VarInfo of the variable.
* @param condition the condition in which the variable occurs.
* @return the type converted to index type if needed.
*/
private static String makeIndexIfNeeded(
String type, String name, VarInfo varInfo, String condition) throws ParseException {
if ((type.equals("int") || varInfo.type.isArray())
&& varInfo.file_rep_type != ProglangType.HASHCODE) {
int LPAREN = 74;
int RPAREN = 75;
int LBRACKET = 78;
int RBRACKET = 79;
Stack<Boolean> inArrayIndex = new Stack<Boolean>();
inArrayIndex.push(Boolean.FALSE);
NodeToken[] tokens = TokenExtractor.extractTokens(condition);
for (int i = 0; i < tokens.length; i++) {
if (tokens[i].kind == LBRACKET) {
inArrayIndex.push(Boolean.TRUE);
} else if (tokens[i].kind == RBRACKET) {
inArrayIndex.pop();
} else if (tokens[i].kind == LPAREN) {
inArrayIndex.push(Boolean.FALSE);
} else if (tokens[i].kind == RPAREN) {
inArrayIndex.pop();
} else if (inArrayIndex.peek().booleanValue() && tokens[i].tokenImage.equals(name)) {
if (type.equals("int") || type.equals("int_index")) {
// Note the type can only equal "int_index" if the variable
// was already visited by this if statement since it appears
// more than once in the condition.
type = "int_index";
} else {
type = "index[]";
}
}
}
return type;
}
return type;
}
/* 145 */
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> res = new LinkedList<Integer>();
if (root == null) return res;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root);
TreeNode prev = null;
while (!stack.isEmpty()) {
TreeNode cur = stack.peek();
if (prev == null || prev.left == cur || prev.right == cur) {
if (cur.left != null) stack.push(cur.left);
else if (cur.right != null) stack.push(cur.right);
else {
res.add(cur.val);
stack.pop();
}
} else if (cur.left == prev) {
if (cur.right != null) stack.push(cur.right);
else {
res.add(cur.val);
stack.pop();
}
} else if (cur.right == prev) {
res.add(cur.val);
stack.pop();
}
prev = cur;
}
return res;
}
/**
* The if...else... statements have been used to concentrate on the Interpreter pattern. A better
* approach would be to use a separate pattern to hande each token such as that defined in Chain
* of Responsibility.
*/
public City evaluate(String route) {
// Define the syntax tree
Stack<Expression> expressionStack = new Stack<Expression>();
// Parse each token in route string
for (String token : route.split(" ")) {
// Is token a recognised city?
if (cities.containsKey(token)) {
City city = cities.get(token);
expressionStack.push(new CityExpression(city));
// Is token to find most northerly?
} else if (token.equals("northerly")) {
expressionStack.push(new MostNortherlyExpression(loadExpressions(expressionStack)));
// Is token to find most southerly?
} else if (token.equals("southerly")) {
expressionStack.push(new MostSoutherlyExpression(loadExpressions(expressionStack)));
// Is token to find most westerly?
} else if (token.equals("westerly")) {
expressionStack.push(new MostWesterlyExpression(loadExpressions(expressionStack)));
// Is token to find most easterly?
} else if (token.equals("easterly")) {
expressionStack.push(new MostEasterlyExpression(loadExpressions(expressionStack)));
}
}
// Resulting value
return expressionStack.pop().interpret();
}
/**
* 创建新的buffer，保存老的buffer。
*
* @throws IllegalStateException 如果不在buffer模式，或<code>getWriter</code> 方法曾被调用，或<code>
* getOutputStream</code>方法从未被调用
*/
public void pushBuffer() {
if (!buffering) {
throw new IllegalStateException("Buffering mode is required to pushBuffer");
}
if (stream == null && writer == null) {
throw new IllegalStateException(
"getOutputStream() or getWriter() method has not been called yet");
}
flushBufferAdapter();
// 向stream或writer stack中压入新的buffer。
if (stream != null) {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
bytesStack.push(bytes);
((BufferedServletOutputStream) stream).updateOutputStream(bytesStack.peek());
logger.logMessage(
LogLevel.DEBUG, "Pushed new byte buffer (stack size is " + bytesStack.size() + ")");
} else {
StringWriter chars = new StringWriter();
charsStack.push(chars);
((BufferedServletWriter) writer).updateWriter(charsStack.peek());
logger.logMessage(
LogLevel.DEBUG, "Pushed new character buffer (stack size is " + charsStack.size() + ")");
}
}
public int cal(String input) throws SyntaxErrorException {
// initiates the empty stack
operands = new Stack<Integer>();
// tokenizes the input by space
String[] tokens = input.split("\\s+");
try {
for (String eachToken : tokens) {
char first = eachToken.charAt(0);
if (Character.isDigit(first)) {
int value = Integer.parseInt(eachToken);
operands.push(value);
} else if (isOperator(first)) {
int result = calOps(first);
operands.push(result);
} else {
throw new SyntaxErrorException("Invalid character ! " + first);
}
} // end of for loop
// the case of no more tokens - pop result from stack
int answer = operands.pop();
if (operands.empty()) {
return answer;
} else {
throw new SyntaxErrorException("Stack is not empty...");
}
} catch (EmptyStackException ex) {
throw new SyntaxErrorException("It attempts to pop the empty stack .. ");
}
}
// DFS - stack
public boolean validTree(int n, int[][] edges) {
List<Set<Integer>> graph = new ArrayList<Set<Integer>>();
for (int i = 0; i < n; i++) {
graph.add(new HashSet<Integer>());
}
for (int[] edge : edges) {
graph.get(edge[0]).add(edge[1]);
graph.get(edge[1]).add(edge[0]);
}
boolean[] visited = new boolean[n];
Stack<Integer> q = new Stack<Integer>();
q.push(0);
while (!q.isEmpty()) {
int node = q.pop();
if (visited[node]) return false;
visited[node] = true;
for (int neis : graph.get(node)) {
graph.get(neis).remove(node);
q.push(neis);
}
}
for (boolean i : visited) {
if (!i) return false;
}
return true;
}
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;
}
// check that algorithm computes either the topological order or finds a directed cycle
private void dfs(EdgeWeightedDigraph G, int v) {
onStack[v] = true;
marked[v] = true;
for (DirectedEdge e : G.adj(v)) {
int w = e.to();
// short circuit if directed cycle found
if (cycle != null) return;
// found new vertex, so recur
else if (!marked[w]) {
edgeTo[w] = e;
dfs(G, w);
}
// trace back directed cycle
else if (onStack[w]) {
cycle = new Stack<DirectedEdge>();
while (e.from() != w) {
cycle.push(e);
e = edgeTo[e.from()];
}
cycle.push(e);
}
}
onStack[v] = false;
}
public static void main(String[] args) {
Stack s = new Stack();
s.push(1);
s.push(2);
s.push(3);
assert (s.peek().equals(3));
s.pop();
assert (s.peek().equals(2));
s.pop();
s.push(4);
assert (s.peek().equals(4));
s.pop();
s.pop();
try {
s.pop();
} catch (Exception e) {
System.out.println("empty stack");
System.out.println(e.getMessage());
}
Queue q = new Queue();
q.enqueue(1);
q.enqueue(2);
assert (q.head().equals(1));
q.dequeue();
assert (q.head().equals(2));
q.dequeue();
try {
q.dequeue();
} catch (Exception e) {
System.out.println("empty queue");
System.out.println(e.getMessage());
}
}
// check that algorithm computes either the topological order or finds a directed cycle
private void dfs(Digraph G, int v) {
onStack[v] = true;
marked[v] = true;
for (int w : G.adj(v)) {
// short circuit if directed cycle found
if (cycle != null) return;
// found new vertex, so recur
else if (!marked[w]) {
edgeTo[w] = v;
dfs(G, w);
}
// trace back directed cycle
else if (onStack[w]) {
cycle = new Stack<Integer>();
for (int x = v; x != w; x = edgeTo[x]) {
cycle.push(x);
}
cycle.push(w);
cycle.push(v);
}
}
onStack[v] = false;
}
private void opStack(String operator) {
// Push operator into the stack if it is empty
if (opStack.empty()) {
opStack.push(operator);
return;
}
// Push operator into the stack if it is a left bracket
if ("(".equals(operator)) {
opStack.push(operator);
return;
}
// Pop all elements in the stack to the output if meet the right bracket
if (")".equals(operator)) {
String tmp = "";
while (!"(".equals(tmp = opStack.pop())) {
postfixExpression.add(tmp);
}
return;
}
// Push any operator into the stack if the previous operator is left bracket
if ("(".equals(opStack.peek())) {
opStack.push(operator);
return;
}
if (comparePriority(operator, opStack.peek())) {
opStack.push(operator);
return;
}
}
/**
* 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());
}
/**
* Returns a path between the source vertex <tt>s</tt> and vertex <tt>v</tt>, or <tt>null</tt> if
* no such path.
*
* @param v the vertex
* @return the sequence of vertices on a path between the source vertex <tt>s</tt> and vertex
* <tt>v</tt>, as an Iterable
*/
public Iterable<Integer> pathTo(int v) {
if (!hasPathTo(v)) return null;
Stack<Integer> path = new Stack<Integer>();
for (int x = v; x != s; x = edgeTo[x]) path.push(x);
path.push(s);
return path;
}
/** 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 area = 0, border;
Stack<Node> heightStack = new Stack<Node>();
heightStack.push(new Node(-1, -1));
Node temNode;
for (int i = 0; i < height.length; i++) {
if (heightStack.peek().height < height[i]) {
heightStack.push(new Node(height[i], i));
} else {
temNode = heightStack.peek();
border = temNode.index;
while (heightStack.peek().height > height[i]) {
temNode = heightStack.pop();
area = Math.max((border - heightStack.peek().index) * temNode.height, area);
}
area = Math.max((i - heightStack.peek().index) * height[i], area);
heightStack.push(new Node(height[i], i));
}
}
border = heightStack.peek().index;
while (!heightStack.empty()) {
Node tem = heightStack.pop();
if (heightStack.empty()) return area;
area = Math.max(area, tem.height * (border - heightStack.peek().index));
}
return area;
}
public int longestValidParentheses(String s) {
Stack<int[]> stack = new Stack<int[]>();
int result = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(') {
int[] a = {i, 0};
stack.push(a);
} else {
if (stack.empty() || stack.peek()[1] == 1) {
int[] a = {i, 1};
stack.push(a);
} else {
stack.pop();
int currentLen = 0;
if (stack.empty()) {
currentLen = i + 1;
} else {
currentLen = i - stack.peek()[0];
}
result = Math.max(result, currentLen);
}
}
}
return result;
}
public static boolean pastTM_Al(Stack s) {
byte[] topElmt = ((Entry) s.peek()).getPart();
byte[] oldTopElmt = topElmt;
if (BooleanMethod.endsWith_PastTMHuman_Al(topElmt)) {
// clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "TM_Al");
s.pop();
s.push(new Entry(Constant.Al, Tag.ConditionalSuffix));
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.Al.length);
s.push(new Entry(topElmt, -1, oldTopElmt));
Tense.human(s);
return true;
}
if (BooleanMethod.endsWith_PastTMHuman_Alum(topElmt)) {
// clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "TM_Alum");
s.pop();
s.push(new Entry(Constant.um, Tag.Clitic));
s.push(new Entry(Constant.Al, Tag.ConditionalSuffix));
topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.Alum.length);
s.push(new Entry(topElmt, -1, oldTopElmt));
Tense.human(s);
return true;
}
return false;
}
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;
}
private void evaluateStack() {
if (stack.isNull()) throw new IllegalArgumentException("stack");
Stack thisStack = stack;
int total = 0;
while (thisStack != null) {
String val = thisStack.pop();
if (val.equals("+")) {
String int1 = thisStack.pop();
String int2 = thisStack.pop();
total = Integer.parseInt(int1) + Integer.parseInt(int2);
thisStack.push(Integer.toString(total));
} else if (val.equals("s")) {
String int1 = thisStack.pop();
String int2 = thisStack.pop();
thisStack.push(int1);
thisStack.push(int2);
}
}
}
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;
}
