Write an efficient algorithm that searches for a value in an m x n matrix.
This matrix has the following properties:
- Integers in each row are sorted from left to right.
- The first integer of each row is greater than the last integer of the previous row.
Consider the following matrix:
[
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
Given target = 3, return true.
O(log(n) + log(m)) time
public class Solution {
/**
* @param matrix, a list of lists of integers
* @param target, an integer
* @return a boolean, indicate whether matrix contains target
*/
public boolean searchMatrix(int[][] matrix, int target) {
// write your code here
if(matrix==null || matrix.length==0){
return false;
}
int height=matrix.length, width=matrix[0].length;
int start=0, end=height*width-1;
while(start+1<end){
int mid=start+(end-start)/2;
int cur=matrix[mid/width][mid%width];
if(cur==target){
return true;
}else if(cur<target){
start=mid;
}else{
end=mid;
}
}
if(matrix[start/width][start%width]==target){
return true;
}else if(matrix[end/width][end%width]==target){
return true;
}
return false;
}
}Median of two Sorted Arrays
There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays.
Given A=[1,2,3,4,5,6] and B=[2,3,4,5],
the median is 3.5.
Given A=[1,2,3] and B=[4,5],
the median is 3.
The overall run time complexity should be O(log
(m+n)).
class Solution {
/**
* @param A: An integer array.
* @param B: An integer array.
* @return: a double whose format is *.5 or *.0
*/
public double findMedianSortedArrays(int[] A, int[] B) {
int length=A.length+B.length;
if(length%2==0){
return (findKth(A,0,B,0,length/2)+findKth(A,0,B,0,length/2+1))/2.0;
}
return findKth(A,0,B,0,length/2+1);
}
private int findKth(int[] A,int startA,int[] B,int startB,int k){
if(startA>=A.length){
return B[startB+k-1];
}
if(startB>=B.length){
return A[startA+k-1];
}
if(k==1){
return Math.min(A[startA],B[startB]);
}
int valueA=startA+k/2-1<A.length?A[startA+k/2-1]:Integer.MAX_VALUE;
int valueB=startB+k/2-1<B.length?B[startB+k/2-1]:Integer.MAX_VALUE;
if(valueA<valueB){
return findKth(A,startA+k/2,B,startB,k-k/2);
}
return findKth(A,startA,B,startB+k/2,k-k/2);
}
}Top K Frequent Words (Map Reduce)
Find top k frequent words with map reduce framework.
The mapper's key is the document id, value is the content of the document, words in a document are split by spaces.
For reducer, the output should be at most k key-value pairs, which are the top k words and their frequencies in this reducer. The judge will take care about how to merge different reducers' results to get the global top k frequent words, so you don't need to care about that part.
The k is given in the constructor of TopK class.
For the words with same frequency, rank them with alphabet.
Given document A =
lintcode is the best online judge
I love lintcode
and document B =
lintcode is an online judge for coding interview
you can test your code online at lintcode
The top 2 words and their frequencies should be
lintcode, 4
online, 3/**
* Definition of OutputCollector:
* class OutputCollector<K, V> {
* public void collect(K key, V value);
* // Adds a key/value pair to the output buffer
* }
* Definition of Document:
* class Document {
* public int id;
* public String content;
* }
*/
class Pair {
String key;
int value;
Pair(String key, int value) {
this.key = key;
this.value = value;
}
}
public class TopKFrequentWords {
public static class Map {
public void map(String _, Document value,
OutputCollector<String, Integer> output) {
// Write your code here
// Output the results into output buffer.
// Ps. output.collect(String key, int value);
int id = value.id;
StringBuffer temp = new StringBuffer("");
String content = value.content;
String[] words = content.split(" ");
for (String word : words)
if (word.length() > 0) {
output.collect(word, 1);
}
}
}
public static class Reduce {
private PriorityQueue<Pair> Q = null;
private int k;
private Comparator<Pair> pairComparator = new Comparator<Pair>() {
public int compare(Pair left, Pair right) {
if (left.value != right.value) {
return left.value - right.value;
}
return right.key.compareTo(left.key);
}
};
public void setup(int k) {
// initialize your data structure here
this.k = k;
Q = new PriorityQueue<Pair>(k, pairComparator);
}
public void reduce(String key, Iterator<Integer> values) {
// Write your code here
int sum = 0;
while (values.hasNext()) {
sum += values.next();
}
Pair pair = new Pair(key, sum);
if (Q.size() < k) {
Q.add(pair);
} else {
Pair peak = Q.peek();
if (pairComparator.compare(pair, peak) > 0) {
Q.poll();
Q.add(pair);
}
}
}
public void cleanup(OutputCollector<String, Integer> output) {
// Output the top k pairs <word, times> into output buffer.
// Ps. output.collect(String key, Integer value);
List<Pair> pairs = new ArrayList<Pair>();
while (!Q.isEmpty()) {
pairs.add(Q.poll());
}
// reverse result
int n = pairs.size();
for (int i = n - 1; i >= 0; --i) {
Pair pair = pairs.get(i);
output.collect(pair.key, pair.value);
}
}
}
}Remove Node in Binary Search Tree
Given a root of Binary Search Tree with unique value for each node. Remove the node with given value. If there is no such a node with given value in the binary search tree, do nothing. You should keep the tree still a binary search tree after removal.
Given binary search tree:
5
/ \
3 6
/ \
2 4
Remove 3, you can either return:
5
/ \
2 6
\
4
or
5
/ \
4 6
/
2/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of the binary search tree.
* @param value: Remove the node with given value.
* @return: The root of the binary search tree after removal.
*/
public TreeNode removeNode(TreeNode root, int value) {
TreeNode dummy = new TreeNode(0);
dummy.left = root;
TreeNode parent = findNode(dummy, root, value);
TreeNode node;
if (parent.left != null && parent.left.val == value) {
node = parent.left;
} else if (parent.right != null && parent.right.val == value) {
node = parent.right;
} else {
return dummy.left;
}
deleteNode(parent, node);
return dummy.left;
}
private TreeNode findNode(TreeNode parent, TreeNode node, int value) {
if (node == null) {
return parent;
}
if (node.val == value) {
return parent;
}
if (value < node.val) {
return findNode(node, node.left, value);
} else {
return findNode(node, node.right, value);
}
}
private void deleteNode(TreeNode parent, TreeNode node) {
if (node.right == null) {
if (parent.left == node) {
parent.left = node.left;
} else {
parent.right = node.left;
}
} else {
TreeNode temp = node.right;
TreeNode father = node;
while (temp.left != null) {
father = temp;
temp = temp.left;
}
if (father.left == temp) {
father.left = temp.right;
} else {
father.right = temp.right;
}
if (parent.left == node) {
parent.left = temp;
} else {
parent.right = temp;
}
temp.left = node.left;
temp.right = node.right;
}
}
}Rotate String
Given a string and an offset, rotate string by offset. (rotate from left to right)
Given "abcdefg".
offset=0 => "abcdefg"
offset=1 => "gabcdef"
offset=2 => "fgabcde"
offset=3 => "efgabcd"
Rotate in-place with O(1) extra memory.
public class Solution {
/**
* @param str: an array of char
* @param offset: an integer
* @return: nothing
*/
public void rotateString(char[] str, int offset) {
if(offset==0){
return;
}
if(str==null || str.length==0){
return;
}
int n=str.length;
offset=offset%n;
reverse(str,0,n-offset-1);
reverse(str,n-offset,n-1);
reverse(str,0,n-1);
}
private void reverse(char[] str,int start,int end){
while(start<end){
char temp=str[start];
str[start]=str[end];
str[end]=temp;
start++;
end--;
}
}
}Digit Counts
Count the number of k's between 0 and n. k can be 0 - 9.
if n = 12, k = 1 in
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
we have FIVE 1's (1, 10, 11, 12)
class Solution {
/*
* param k : As description.
* param n : As description.
* return: An integer denote the count of digit k in 1..n
*/
public int digitCounts(int k, int n) {
// write your code here
int cnt = 0;
for (int i = k; i <= n; i++) {
cnt += singleCount(i, k);
}
return cnt;
}
public int singleCount(int i, int k) {
if (i == 0 && k == 0)
return 1;
int cnt = 0;
while (i > 0) {
if (i % 10 == k) {
cnt++;
}
i = i / 10;
}
return cnt;
}
};Word Search
Given a 2D board and a word, find if the word exists in the grid.
The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
Given board =
[ "ABCE", "SFCS", "ADEE" ]
word = "ABCCED",
-> returns true,
word = "SEE",
-> returns true,
word = "ABCB",
-> returns false.
public class Solution {
/**
* @param board: A list of lists of character
* @param word: A string
* @return: A boolean
*/
public boolean exist(char[][] board, String word) {
if(board == null || board.length == 0)
return false;
if(word.length() == 0)
return true;
for(int i = 0; i< board.length; i++){
for(int j=0; j< board[0].length; j++){
if(board[i][j] == word.charAt(0)){
boolean rst = find(board, i, j, word, 0);
if(rst)
return true;
}
}
}
return false;
}
private boolean find(char[][] board, int i, int j, String word, int start){
if(start == word.length())
return true;
if (i < 0 || i>= board.length ||
j < 0 || j >= board[0].length || board[i][j] != word.charAt(start)){
return false;
}
board[i][j] = '#';
boolean rst = find(board, i-1, j, word, start+1)
|| find(board, i, j-1, word, start+1)
|| find(board, i+1, j, word, start+1)
|| find(board, i, j+1, word, start+1);
board[i][j] = word.charAt(start);
return rst;
}
}LRU Cache
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
get(key) - Get the value (will always be positive) of the key if the
key exists in the cache, otherwise return -1.set(key, value) - Set or insert the value if the key is not already
present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
class Node{
Node pre;
Node next;
int key;
int val;
public Node(int key,int val){
this.key=key;
this.val=val;
this.pre=null;
this.next=null;
}
}
public class LRUCache {
private int capacity;
private Node head=new Node(-1,-1);
private Node tail=new Node(-1,-1);
Map<Integer,Node> map=new HashMap<>();
public LRUCache(int capacity) {
this.capacity=capacity;
head.next=tail;
tail.pre=head;
}
public int get(int key) {
if(!map.containsKey(key)){
return -1;
}
Node cur=map.get(key);
cur.pre.next=cur.next;
cur.next.pre=cur.pre;
moveToTail(cur);
return map.get(key).val;
}
public void set(int key, int value) {
if(get(key)!=-1){
map.get(key).val=value;
return;
}
if(map.size()==capacity){
map.remove(head.next.key);
head.next=head.next.next;
head.next.pre=head;
}
Node newNode=new Node(key,value);
map.put(key,newNode);
moveToTail(newNode);
}
private void moveToTail(Node cur){
cur.pre=tail.pre;
tail.pre=cur;
cur.pre.next=cur;
cur.next=tail;
}
}
