lintcode做题总结, Sept 30

1. LRU Cache 这个题思路不麻烦，但是挺tricky的，思路是把节点不但存进map里还要连成队列。现在我这里多用了head 和 end两个节点，这样虽然浪费一点空间，但是代码会简练很多。

public class LRUCache {
    private class Node {
        int key;
        int val;
        Node pre = null;
        Node next = null;
        Node (int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    HashMap<Integer, Node> map = new HashMap<Integer, Node>();
    int capacity = 0;
    Node head = new Node(0, 0);
    Node end = new Node(0, 0);


    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = end;

    }

    public int get(int key) {
        if (map.containsKey(key)) {
            Node n = map.get(key);
            remove(n);
            addHead(n);
            return n.val;
        } else {
            return -1;
        }
    }

    public void set(int key, int value) {
        if (map.containsKey(key)) {
            Node n = map.get(key);
            n.val = value;
            remove(n);
            addHead(n);
        } else {
            if (map.size() == this.capacity) {
                Node last = end.pre;
                remove(last);
                map.remove(last.key);
            }
            Node n = new Node(key, value);
            addHead(n);
            map.put(key, n);
        }

    }

    private void remove (Node n) {

        n.pre.next = n.next;
        n.next.pre = n.pre;


    }

    private void addHead (Node n) {
        if (head.next == end) {
            head.next = n;
            n.pre = head;
            n.next = end;
            end.pre = n;
        } else {
            n.next = head.next;
            head.next = n;
            n.pre = head;
            n.next.pre = n;

        }

    }
}

2. Substring with Concatenation of All Words

public class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        if(s==null||s.length()==0||words==null||words.length==0){
            return result;
        } 
     
        //frequency of words
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for(String w: words){
            if(map.containsKey(w)){
                map.put(w, map.get(w)+1);
            }else{
                map.put(w, 1);
            }
        }
     
        int len = words[0].length();
        //j means start point
        for(int j=0; j<len; j++){
            HashMap<String, Integer> currentMap = new HashMap<String, Integer>();
            int start = j;//start index of start
            int count = 0;//count totoal qualified words so far
     
            for(int i=j; i<=s.length()-len; i=i+len){
                String sub = s.substring(i, i+len);
                if(map.containsKey(sub)){
                    //set frequency in current map
                    if(currentMap.containsKey(sub)){
                        currentMap.put(sub, currentMap.get(sub)+1);
                    }else{
                        currentMap.put(sub, 1);
                    }
     
                    count++;
     
                    while(currentMap.get(sub)>map.get(sub)){
                        //Keeping removing elements from start until removing sub
                        String left = s.substring(start, start+len);
                        currentMap.put(left, currentMap.get(left)-1);
                        count--;
                        start = start + len;
                    }
     
     
                    if(count==words.length){
                        result.add(start); //add to result
     
                        //removing fisrt word and keeping searching         
                        String left = s.substring(start, start+len);
                        currentMap.put(left, currentMap.get(left)-1);
                        count--;
                        start = start + len;
                    }
                }else{
                    //if a substring is not in the map, starting over.
                    currentMap.clear();
                    start = i+len;
                    count = 0;
                }
            }
        }
    
        return result;
    }
}

3. Sudoku Solver这道题是之前数独的加强型，就是使用回溯法一个一个填然后检查即可

public class Solution {
    public void solveSudoku(char[][] board) {  
        if(board == null || board.length != 9 || board[0].length !=9)  
            return;  
        helper(board,0,0);  
    }  
    private boolean helper(char[][] board, int i, int j) {  
        if(j>=9)  
            return helper(board,i+1,0);  
        if(i==9)  
        {  
            return true;  
        }  
        if(board[i][j]=='.')  
        {  
            for(int k=1;k<=9;k++)  
            {  
                board[i][j] = (char)(k+'0');  
                if(isValid(board,i,j))  
                {  
                    if(helper(board,i,j+1))  
                        return true;  
                }  
                board[i][j] = '.';  
            }  
        }  
        else  
        {  
            return helper(board,i,j+1);  
        }  
        return false;  
    }  
    private boolean isValid(char[][] board, int i, int j) {  
        for(int k=0;k<9;k++) {  
            if(k!=j && board[i][k]==board[i][j])  
                return false;  
        }  
        for(int k=0;k<9;k++){  
            if(k!=i && board[k][j]==board[i][j])  
                return false;  
        }          
        for(int row = i/3*3; row<i/3*3+3; row++){  
            for(int col=j/3*3; col<j/3*3+3; col++){  
                if((row!=i || col!=j) && board[row][col]==board[i][j])  
                    return false;  
            }  
        }  
        return true;  
    }
}

4. Merge Intervals 先按照start排序，然后历遍比较即可。

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        List<Interval> res = new ArrayList<Interval>();
        if (intervals == null || intervals.size() == 0){
            return res;
        }
        Collections.sort(intervals, new IntervalComparator());
        int start = intervals.get(0).start;
        int end = intervals.get(0).end;
        Interval ele = new Interval(start, end);
        for (int i = 1; i < intervals.size(); i++){
            if (intervals.get(i).start > ele.end){
                res.add(ele);
                ele = new Interval(intervals.get(i).start, intervals.get(i).end);
            } else {
                if (intervals.get(i).end > ele.end){
                    ele.end = intervals.get(i).end;
                }
            }
        }
        if (ele != null){
            res.add(ele);
        }
        return res;
    }
    class IntervalComparator implements Comparator<Interval> {
    	public int compare(Interval i1, Interval i2) {
    		return i1.start - i2.start;
    	}
    }
    
}