You have an integer n representing the number of courses you need to take and the courses are labeled from 0 to n-1.
Some courses have prerequisite courses. In order to take course 0, you need to have completed course 1. This is represented as a pair: [0, 1].
Given n and a list of pairs representing prerequisite courses, return the ordering of courses to complete all the courses from 0 to n-1.
Return an empty array if no such ordering exists. If there are multiple orderings, return the order that is lexicographically smallest.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 2, [[1,0]] 
Output: <code>[0,1]</code> Explanation:&nbsp;In order to take course 1 you need to complete course 0. So the output would be <code>[0,1] .</code></pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 4, [[1,0],[2,0],[3,1],[3,2]]
Output: <code>[0,1,2,3]</code> Explanation:&nbsp;There are a total of 4 courses to take. In order to take course 3 you should have completed courses 1 and 2. Both courses 1 and 2 should be taken after you complete course 0. One correct course order is <code>[0,1,2,3]</code> it's the lexicographically smallest. Another correct ordering is <code>[0,2,1,3]</code>&nbsp;but&nbsp;it's&nbsp;not&nbsp;the&nbsp;lexicographically&nbsp;smallest.</pre>

Schedule Classes

Given the root of a binary tree, return the leftmost value in the last row of the tree.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;">
 2
 / \
 1 3
</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;">
Output:
1
</pre>
 Example 2: 
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:

 1
 / \
 2 3
 / / \
 4 5 6
 /
 7

Output:
7
</pre>
You can assume valid input and the root node is not NULL.

Binary Tree Left Most Value

Given n nodes which are labeled from 0 to n-1 and a 2D list representing undirected edges (each edge is represented as a pair of nodes), return true if the edges make a tree.
Assume valid input and no repeated edges in the list of given edges. [0,1] and [1,0] are the same so they won't occur more than once in the list of given edges.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code>, and <code>edges = [[0,1], [0,2], [0,3], [1,4]]</code> Output: true</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5, </code>and <code>edges = [[0,1], [1,2], [2,3], [1,3], [1,4]]</code> Output: false</pre>
&nbsp;

Valid Tree

Given a binary tree, return the minimum depth.
The minimum depth is the shortest path from the root node to a leaf node. A leaf node has no children.
Example:
Given the tree <code>[3,9,20,null,null,15,7]</code>,
<pre style="white-space: pre-wrap; word-break: keep-all;"> 3
 / \
 9 20
 / \
 15 7</pre>
return 2.

Binary Tree Min Depth

Given an integer n which represents n nodes labeled from 0 to n-1 and a list of edges (each edge is a pair of nodes), return the number of connected components in the undirected graph.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code> and <code>edges = [[0, 1], [1, 2], [3, 4]]</code></pre>
<pre> 0 3
 | |
 1 --- 2 4 Output: 2</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>n = 5</code> and <code>edges = [[0, 1], [1, 2], [2, 3], [3, 4]]</code> </pre>
<pre> 0 4
 | |
 1 --- 2 --- 3</pre>
<pre style="white-space: pre-wrap; word-break: keep-all;"> Output:&nbsp;&nbsp;1</pre>
Note: Assume there are no duplicate edges that appear. [1, 0] is the same as [0, 1] and they wont appear twice.

Count Connected Components In Graph

Given a string, remove the minimum number of invalid parentheses&nbsp;such that the input string is valid. Return a list of all possible results in sorted order.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "()())()"
Output: ["()()()", "(())()"]
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "(a)())()"
Output: ["(a)()()", "(a())()"]
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: ")("
Output: [""]
</pre>

Delete Incorrect Brackets

Given a 2D array every call can have one of three values:
<ul>
<li>0 represents an empty cell</li>
<li>1 represents a good orange</li>
<li>2 represents a bad orange</li>
</ul>
&nbsp;
For every minute, a good orange that is adjacent (top, bottom, left, right) to a bad orange becomes bad. Return the minimum minutes that must elapse such that all oranges are bad. If that is impossible return -1.
&nbsp;
<div>
Example 1:
<img style="width: auto; height: 100px;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/bad-oranges/example-1-fixed.png" alt="" />
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [[2,1,1],[1,1,0],[0,1,1]]
Output: 4
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [[2,1,1],[0,1,1],[1,0,1]]
Output: -1
Explanation: The orange in the bottom left corner (row 2, column 0) is never bad, because bad oranges only spread from top, bottom, left and right.
</pre>
<div>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [[0,2]]
Output: 0
Explanation: Since there are already no good oranges to begin with, the answer is 0.
</pre>
&nbsp;
</div>
</div>
</div>

Bad Oranges

You are given a grid of a city in a 2D array. The grid has 3 values: 0, 1, or 2 which represent:
<ul>
<li>0 means empty land which you can pass through freely</li>
<li>1 means there is a building there and you can't pass through freely.</li>
<li>2 marks an obstacle which you cannot pass through</li>
</ul>
You want to build a house on empty land such that you are in the shortest distance to all buildings. Return the shortest total distance to all buildings from the optimal placement of the house. If you cannot build a house anywhere return -1.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [ [1,0,2,0,1], [0,0,0,0,0], [0,0,1,0,0] ]

1 - 0 - 2 - 0 - 1
| | | | |
0 - 0 - 0 - 0 - 0
| | | | |
0 - 0 - 1 - 0 - 0

Output: 7 

Explanation: Given three buildings at <code>(0,0)</code>, <code>(0,4)</code>, <code>(2,2)</code>, and an obstacle at <code>(0,2), t</code>he optimal point for a houe is <code>(1,2)</code>, and the total travel distance to all buildings: 3+3+1=7 is minimal. So return 7.</pre>
&nbsp;

Build Optimal Location House

Given an NxN board with numbers from 1 to N*N written boustrophedonically (starts from the bottom left of the board and alternates direction each row). For example a 6x6 board is written as:
<img style="width: auto; height: 200px;" src="https://swecareers-images.s3.us-east-2.amazonaws.com/images/snakes-and-ladders/example-1.png" alt="" />

You start at the beginning square (last row, first column). For every move starting at square x you can make a move to one of: x + 1, x + 2, x + 3, x + 4, x + 5, x + 6 as long as the destination is &lt;= N*N. If the destination square has a snake or ladder you move your position that the snake or ladder points to. Return the least number of moves to reach square N*N. If you can never reach the square N*N then return -1.
Note that you can only use a snake or ladder once per turn. If there are multiple snakes and ladders then only the first snake or ladder works. The board is represented as all -1s except for the positions where snakes/ladders exist. The snakes/ladders will have the position that you must move to.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: [
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]]
Output: 4
Explanation: 
At the beginning, you begin at square 1 [at row 5, column 0].
You move to square 2, and must take the ladder to square 15.
You move to square 17 (row 3, column 5), and take the snake to square 13.
You move to square 14, and must take the ladder to square 35.
You then decide to move to square 36, ending the game.
It can be shown that you need at least 4 moves to reach the N*N-th square, so the answer is 4.
</pre>
Note:
<ol>
<li><code>2 &lt;= board.length = board[0].length&nbsp;&lt;= 20</code></li>
<li><code>board[i][j]</code>&nbsp;is between <code>1</code> and <code>N*N</code> or is equal to <code>-1</code>.</li>
<li>The board&nbsp;square with number <code>1</code> has no snake or ladder.</li>
<li>The board square with number <code>N*N</code> has no snake or ladder.</li>
</ol>

Snakes And Ladders

Given 2 strings called beginWord and endWord, and a list of words called dictionary, return the length of the shortest path to get from the beginWord to the endWord by only transforming one letter at a time to a word that exists in the dictionary.
Return 0 if no path exists to the endWord. Assume all words are lowercase, have the same length and there are no duplicates in the dictionary list.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: The shortest path is "hit" -&gt; "hot" -&gt; "dot" -&gt; "dog" -&gt; "cog",
return length 5.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output:&nbsp;0

Explanation:&nbsp;The endWord "cog" does not exist in the wordList dictionary so return 0.
</pre>

Problem Title	Difficulty	Frequency in Interviews
Delete Incorrect Brackets	Hard
Word Transform	Medium
Schedule Classes	Medium
Build Optimal Location House	Hard
Snakes And Ladders	Medium
Count Connected Components In Graph	Medium
Valid Tree	Medium
Binary Tree Left Most Value	Medium
Bad Oranges	Easy
Binary Tree Min Depth	Easy

Most Frequently Asked Breadth First Search Interview Questions

Sort By: Company Questions

Sort By: Problem Type