面试笔试杂项积累-leetcode 146-150

除夕做的题，贴春联，做饭的时间占用了，，做了十道题，总结之

146.146-LRU Cache-Difficulty: Hard

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.

方法一

思路

模拟LRU catche，最后使用的数据最先删除(如果空间满)

博主开始使用两个链表操作，然后超时，原因应该是remove和add，insert过多，确实没有必要，可以实现，但是超时

   IList<int> _value = new List<int>();    IList<int> _key = new List<int>();    int capacity = 0;    public test146(int capacity)    {        this.capacity = capacity;    }    public int Get(int key)    {        if (_key.Contains(key))        {            int index = _key.IndexOf(key);            int key_temp = _key[index];            int value_temp = _value[index];            _key.RemoveAt(index);            _value.RemoveAt(index);            _key.Add(key_temp);            _value.Add(value_temp);            return value_temp;        }        else            return -1;    }    public void Set(int key, int value)    {        if (_key.Contains(key))        {            _value[_key.IndexOf(key)] = value;        }        else        {            if (_value.Count + 1 > capacity)            {                _key.RemoveAt(0);                _value.RemoveAt(0);                _key.Add(key);                _value.Add(value);            }            else            {                _key.Add(key);                _value.Add(value);            }        }    }

方法二

思路

双链表

参考:

https://leetcode.com/discuss/81106/java-easy-version-to-understand

1.The key to solve this problem is using a double linked list which enables us to quickly move nodes.2.The LRU cache is a hash table of keys and double linked nodes. The hash table makes the time of get() to be O(1). The list of double linked nodes make the nodes adding/removal operations O(1).

class Node { int key; int value; Node pre; Node next;

public Node(int key, int value) {    this.key = key;    this.value = value;}

}public class LRUCache {

HashMap<Integer, Node> map; int capicity, count; Node head, tail;

public LRUCache(int capacity) {    this.capicity = capacity;    map = new HashMap<>();    head = new Node(0, 0);    tail = new Node(0, 0);    head.next = tail;    tail.pre = head;    head.pre = null;    tail.next = null;    count = 0;}public void deleteNode(Node node) {    node.pre.next = node.next;    node.next.pre = node.pre;}public void addToHead(Node node) {    node.next = head.next;    node.next.pre = node;    node.pre = head;    head.next = node;}public int get(int key) {    if (map.get(key) != null) {        Node node = map.get(key);        int result = node.value;        deleteNode(node);        addToHead(node);        return result;    }    return -1;}public void set(int key, int value) {    if (map.get(key) != null) {        Node node = map.get(key);        node.value = value;        deleteNode(node);        addToHead(node);    } else {        Node node = new Node(key, value);        map.put(key, node);        if (count < capicity) {            count++;            addToHead(node);        } else {            map.remove(tail.pre.key);            deleteNode(tail.pre);            addToHead(node);        }    }}

方法三

思路

键值对KeyValuePair作为Dictionary的value

参考：

https://miafish.wordpress.com/2015/01/27/leetcode-ojc-lru-cache/

public class LRUCache {     public class Node    {        public KeyValuePair<int, int> KeyValue { get; set; }        public Node Next { get; set; }        public Node Previous { get; set; }        public Node(int key, int value)        {            this.KeyValue = new KeyValuePair<int,int>(key, value);            Next = null;            Previous = null;        }    }   private readonly int capacity;        private int count;        private readonly Node head;        private readonly Dictionary<int, Node> myDictionary;        public LRUCache(int capacity)        {            head = new Node(-1, -1);            head.Next = head;            head.Previous = head;            this.capacity = capacity;            myDictionary = new Dictionary<int, Node>();        }        public int Get(int key)        {            Node node;            myDictionary.TryGetValue(key, out node);            if (node == null)            {                return -1;            }            this.MoveItToFirstElementAfterHead(node);            return node.KeyValue.Value;        }        public void Set(int key, int value)        {            Node node;            myDictionary.TryGetValue(key, out node);            if (node == null)            {                if (this.count == this.capacity)                {                    // remove the last element                    myDictionary.Remove(head.Previous.KeyValue.Key);                    head.Previous = head.Previous.Previous;                    head.Previous.Next = head;                    count--;                }                // create new node and add to dictionary                var newNode = new Node(key, value);                myDictionary[key] = newNode;                this.InsertAfterTheHead(newNode);                // increase count                count++;            }            else            {                node.KeyValue = new KeyValuePair<int, int>(key, value);                this.MoveItToFirstElementAfterHead(node);            }        }        private void MoveItToFirstElementAfterHead(Node node)        {            RemoveCurrentNode(node);            this.InsertAfterTheHead(node);        }        private void InsertAfterTheHead(Node node)        {            // insert after the head            node.Next = this.head.Next;            node.Previous = this.head;            this.head.Next.Previous = node;            this.head.Next = node;        }        private static void RemoveCurrentNode(Node node)        {            // remove current node            node.Previous.Next = node.Next;            node.Next.Previous = node.Previous;        }}

149.149-Max Points on a Line-Difficulty: Hard

Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

思路

找到同一行上最多的points数目，包括任意斜行

博主真的没想到会利用斜率。。。斜率相同即在同一行

参考：

https://leetcode.com/discuss/57464/accepted-java-solution-easy-to-understand

/** * Definition for a point. * public class Point { *     public int x; *     public int y; *     public Point() { x = 0; y = 0; } *     public Point(int a, int b) { x = a; y = b; } * } */public class Solution {    public int MaxPoints(Point[] points) {                if(points.Length <= 0) return 0;        if(points.Length <= 2) return points.Length;        int result = 0;        for(int i = 0; i < points.Length; i++){            Hashtable hm = new Hashtable();            int samex = 1;            int samep = 0;            for(int j = 0; j < points.Length; j++){                if(j != i){                    if((points[j].x == points[i].x) && (points[j].y == points[i].y)){                        samep++;                    }                    if(points[j].x == points[i].x){                        samex++;                        continue;                    }                    double k = (double)(points[j].y - points[i].y) / (double)(points[j].x - points[i].x);                    if(hm.ContainsKey(k)){                                        hm[k]=(int)hm[k] + 1;                    }else{                        hm.Add(k, 2);                    }                    result = Math.Max(result, (int)hm[k] + samep);                }            }            result = Math.Max(result, samex);        }        return result;    }}

150.150-Evaluate Reverse Polish Notation-Difficulty: Medium

Evaluate the value of an arithmetic expression inReverse Polish Notation.

Valid operators are +, -,*, /. Each operand may be an integer or another expression.

Some examples:

  ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9  ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

思路

利用栈，是数压栈，是运算符弹出两个一个伪算式右侧数一个为左侧进行运算，最后栈里剩的数就是结果

public class Solution {    public int EvalRPN(string[] tokens) {            Stack<int> stack = new Stack<int>();        for (int i = 0; i < tokens.Length; i++)        {            if (tokens[i] != "+" && tokens[i] != "-" && tokens[i] != "*" && tokens[i] != "/")            {                stack.Push(int.Parse(tokens[i]));            }            else            {                int r = stack.Peek();                stack.Pop();                int l = stack.Peek();                stack.Pop();                switch (tokens[i])                {                    case "+":                        stack.Push(l + r);                        break;                    case "-":                        stack.Push(l - r);                        break;                    case "*":                        stack.Push(l * r);                        break;                    case "/":                        stack.Push(l / r);                        break;                }            }        }        return stack.Peek();    }}