Amazon coding 题解答

没有过了test，之后回来跟新

1 LRU

/**
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.
*/


//you should have a data structure that you set the capacity,这个解超时了，也不对。没有考虑get要改变Priority

public class LRUCache {
    int numOfItems;
    int capacity;
    //This is to store the key value that has been visited before
    PriorityQueue<pair> queue;
    // //This is to store the key value pair
    // HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    //This should get a priority queue
    //值小的在栈顶，有益处吧

    public class pair{
      int key;
      int value;
      int timeBit;

      public void pair(int key, int value, int timeBit){
        this.key = key;
        this.value = value;
        this.timeBit = timeBit;
      }
    }

    //The way to implement the priority queue in
    public class pairComparator implements Comparator<pair>{
      public int compare(pair a, pair b){
        if(a.timeBit > b.timeBit)
          return 1;
        else if(a.timeBit < b.timeBit)
          return -1;
        return 0;
      }
    }

    public LRUCache(int capacity) {
        this.capacity = capacity;
        Comparator<pair> comparator = new pairComparator();
        queue = new PriorityQueue(capacity,comparator);
        numOfItems = 0;
    }

    //Loop if the cache contatins the value;
    public int get(int key) {
      //loop all the priority queue and find if the key is in the priority queue
      Iterator iterator = queue.iterator();
      while(iterator.hasNext()){
        pair tem = (pair)iterator.next();
        if(tem.key == key)
          return tem.value;
      }
    }

    public void set(int key, int value) {
        //deal with the corner condition that the number of the items equal to 0
        if(capacity <= 0)
          return;

        //The condition that the number of the items is less than the capacity
        if(numOfItems < capacity){
          Iterator iterator = queue.iterator();
          while(iterator.hasNext()){
              pair tem = (pair)iterator.next();
              tem.value++;
          }

          pair newPair = new pair(key, value, 1);
          queue.add(newPair);
          numOfItems++;
        }

        //the condition that the number of items is equal to the capacity
        else{
          queue.pop();
          Iterator iterator = queue.iterator();
          while(iterator.hasNext()){
              pair tem = (pair)iterator.next();
              tem.value++;
          }
          pair pair = new pair(key, value , 1);
          queue.add(pair);
          numOfItems++;
        }
    }
}

2 insert into a sorted circular list

public class circularList{
  ListNode head;
  ListNode tail;
  public circularList(){
    head = new ListNode(-1);
    tail = new ListNode(Max.integer);
    head.pr = tail;
    head.next = tail;
    tail.pre = head;
    tail.next = head;
  }
  public insert(int tem){
    ListNode curr = head;
    //find the first position where value is larger than the current value
    while(tem > curr.val)
    {
      curr = head.next;
    }
    ListNode node = new ListNode(tem);
    node.next = curr;
    node.pre = curr.pre;
    curr.pre.next = node;
    curr.pre = node;
  }
}

//This is a circular listnode in a circular linkedList
public class ListNode{
  ListNode pre;
  ListNode next;
  int val;
  //This is a constructor confuction
  public ListNode(int val){
    this.val = val;
  }
  public ListNode(ListNode pre, ListNode next, int val){
    this.pre = pre;
    this.next = next;
    this.val = val;
  }
}

mate in Maze, 没有通过

public boolean solve(int[][]maze){
  int rowNum = maze.length;
   // when the maze is empty, return true;
  if(rowNum <= 0)
    return true;
  int colNum = maze[0].length;
  if(colNum <=0)
    return true;
  int[][] solution = new int[rowNum][colNum];
  if(helper(maze, 0,0)){
    printSolution(solution);
    return true;
  }
  else{
    System.out.print("there is no such a solution")
    return false;
  }
}
//assume that the 0 in the matrix is the obscles, and 1 is the way we can pass by
public boolean helper(int[][]maze, int row, int col, int[][] solution){
  int rowNum = maze.length;
  int columnNum = maze[0].length;
  if(row >= rowNum || col >= columnNum)
    return false;
  if(row == rowNum - 1 && col == columnNum - 1 && maze[row][col]){
    return true;
    solution[row][col] = 1;
  }
  if(maze[row][col]){
    solution[row][col] = 1;
    if(helper(maze, row + 1, col))
      return true;
    if(helper(maze, row, col + 1))
      return true;
    maze[row][col] = 0;
    solution[row][col] = 0;
    return false;
  }
  return false;
}
//This is to print the solution
public void printSolution(int[][]solution){
  for(int[]row : array){
    System.out.println(Arrays.toString(row));
  }
}