Leetcode——练习

平时没事刷刷Leetcode，还办了个年会员。为了自己150刀。为了自己的大脑投资，从不差钱儿。刷刷题能练习coding，此外看一些别人的优秀的答案，能增长见解。大家共同努力，共勉。

十、Google考题(2)

Name：Unique Email Addresses

Every email consists of a local name and a domain name, separated by the @ sign.

For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.

Besides lowercase letters, these emails may contain '.'s or '+'s.

If you add periods ('.') between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name.  For example, "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address.  (Note that this rule does not apply for domain names.)

If you add a plus ('+') in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to my@email.com.  (Again, this rule does not apply for domain names.)

It is possible to use both of these rules at the same time.

Given a list of emails, we send one email to each address in the list.  How many different addresses actually receive mails?

Example 1:

Input: ["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]
Output: 2
Explanation: "testemail@leetcode.com" and "testemail@lee.tcode.com" actually receive mails

solution:

class Solution {
  public int numUniqueEmails(String[] emails) {
    Set<String> seen = new HashSet();
    for (String email : emails) {
      int i = email.indexOf('@');
      String local = email.substring(0, i);
      String rest = email.substring(i);
      if (local.contains("+")) {
        local = local.substring(0, local.indexOf('+'));
      }
      // Note: one should escape the specific character '.',
      // since it is treated as a regex expression.
      local = local.replaceAll("\.", "");
      seen.add(local + rest);
    }

    return seen.size();
  }
}

九、Google考题(1)

Name：License Key Formatting

You are given a license key represented as a string S which consists only alphanumeric character and dashes. The string is separated into N+1 groups by N dashes.

Given a number K, we would want to reformat the strings such that each group contains exactly K characters, except for the first group which could be shorter than K, but still must contain at least one character. Furthermore, there must be a dash inserted between two groups and all lowercase letters should be converted to uppercase.

Given a non-empty string S and a number K, format the string according to the rules described above

Example 1:

Input: S = "5F3Z-2e-9-w", K = 4

Output: "5F3Z-2E9W"

Explanation: The string S has been split into two parts, each part has 4 characters.
Note that the two extra dashes are not needed and can be removed.

Example 2:

Input: S = "2-5g-3-J", K = 2

Output: "2-5G-3J"

Explanation: The string S has been split into three parts, each part has 2 characters except the first part as it could be shorter as mentioned above.

Solutions:

mySolution:

class Solution {
    public String licenseKeyFormatting(String S, int K) {

        StringBuilder sb = new StringBuilder();

        String s = S.replaceAll("-", "").toUpperCase();
        if (s.length() < K) {
            return s;
        }
        int firstGroupLength = s.length() % K == 0 ? K : s.length() % K;
        int groupNum = (s.length() - firstGroupLength) / K;
        sb.append(s.substring(0, firstGroupLength));
        for (int i = 0; i < groupNum; i++) {
            sb.append("-");
            sb.append(s.substring(firstGroupLength + K * i, firstGroupLength + K * (i + 1)));
        }
        return sb.toString();
    }
}

better solution:

public String licenseKeyFormatting(String S, int K) {
        String newStr = S.replaceAll("-","").toUpperCase();
        StringBuilder sb = new StringBuilder();
        
        int count = 0;
        
        for(int i = newStr.length()-1; i >=0; i--){
            sb.append(newStr.charAt(i));
            count++;
            if(count == K && i != 0){
                sb.append("-");
                count = 0;
            }
        }
        sb.reverse();
        return sb.toString();
    }

八、Amazon考题

 Given a list of reviews, a list of keywords and an integer k. Find the most popular k keywords in order of most to least frequently mentioned.

The comparison of strings is case-insensitive.
Multiple occurances of a keyword in a review should be considred as a single mention.
If keywords are mentioned an equal number of times in reviews, sort alphabetically.

Example 1:

Input:
k = 2
keywords = ["anacell", "cetracular", "betacellular"]
reviews = [
  "Anacell provides the best services in the city",
  "betacellular has awesome services",
  "Best services provided by anacell, everyone should use anacell",
]

Output:
["anacell", "betacellular"]

Explanation:
"anacell" is occuring in 2 different reviews and "betacellular" is only occuring in 1 review.

Example 2:

Input:
k = 2
keywords = ["anacell", "betacellular", "cetracular", "deltacellular", "eurocell"]
reviews = [
  "I love anacell Best services; Best services provided by anacell",
  "betacellular has great services",
  "deltacellular provides much better services than betacellular",
  "cetracular is worse than anacell",
  "Betacellular is better than deltacellular.",
]

Output:
["betacellular", "anacell"]

Explanation:
"betacellular" is occuring in 3 different reviews. "anacell" and "deltacellular" are occuring in 2 reviews, but "anacell" is lexicographically smaller.

代码解决方案：

package com.example.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;

public class Test02 {
    public static void main(String[] args) {
        int k1 = 2;
        String[] keywords1 = { "anacell", "cetracular", "betacellular" };
        String[] reviews1 = { "Anacell provides the best services in the city", "betacellular has awesome services",
                              "Best services provided by anacell, everyone should use anacell", };
        int k2 = 2;
        String[] keywords2 = { "anacell", "betacellular", "cetracular", "deltacellular", "eurocell" };
        String[] reviews2 = { "I love anacell Best services; Best services provided by anacell",
                              "betacellular has great services",
                              "deltacellular provides much better services than betacellular",
                              "cetracular is worse than anacell", "Betacellular is better than deltacellular.", };
        System.out.println(solve(k1, keywords1, reviews1));
        System.out.println(solve(k2, keywords2, reviews2));
    }

    private static List<String> solve(int k, String[] keywords, String[] reviews) {
        List<String> res = new ArrayList<>();
        Set<String> set = new HashSet<>(Arrays.asList(keywords));
        Map<String, Integer> map = new HashMap<>();
        for (String r : reviews) {
            String[] strs = r.split("\W");
            Set<String> added = new HashSet<>();
            for (String s : strs) {
                s = s.toLowerCase();
                if (set.contains(s) && !added.contains(s)) {
                    map.put(s, map.getOrDefault(s, 0) + 1);
                    added.add(s);
                }
            }
        }
        Queue<Map.Entry<String, Integer>> maxHeap = new PriorityQueue<>(
            (a, b) -> a.getValue() == b.getValue() ? a.getKey().compareTo(b.getKey()) : b.getValue() - a.getValue());
        maxHeap.addAll(map.entrySet());
        while (!maxHeap.isEmpty() && k-- > 0) {
            res.add(maxHeap.poll().getKey());
        }
        return res;
    }
}

这道题挺经典的，考察了许多基础知识点。大公司的一些考题，确实能看出技术者的功底。

七、二叉树反转

使用递归的思想：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode right = invertTree(root.right);
        TreeNode left = invertTree(root.left);
        root.right = left;
        root.left = right;
        return root;
    }
}

六、判断一个数字是否为2的N次方

class Solution {
  public boolean isPowerOfTwo(int n) {
    if (n == 0) return false;
    while (n % 2 == 0) n /= 2;
    return n == 1;
  }
}

上面是第一个方法，大家都能想到。复杂度是O（logN）。不多说

接下来重点是第二个方法，用的是bit的运算。我看完答案后，真是佩服作者的功底。牛逼！！！

class Solution {
  public boolean isPowerOfTwo(int n) {
    if (n == 0) return false;
    long x = (long) n;
    return (x & (-x)) == x;
  }
}

这个方法的复杂度为O（1）。

五、寻找宝藏

You have a map that marks the location of a treasure island. Some of the map area has jagged rocks and dangerous reefs. Other areas are safe to sail in. There are other explorers trying to find the treasure. So you must figure out a shortest route to the treasure island.

 Assume the map area is a two dimensional grid, represented by a matrix of characters. You must start from the top-left corner of the map and can move one block up, down, left or right at a time. The treasure island is marked as X in a block of the matrix. X will not be at the top-left corner. Any block with dangerous rocks or reefs will be marked as D. You must not enter dangerous blocks. You cannot leave the map area. Other areas O are safe to sail in. The top-left corner is always safe. Output the minimum number of steps to get to the treasure.

Example:

 Input:

[['O', 'O', 'O', 'O'],
 ['D', 'O', 'D', 'O'],
 ['O', 'O', 'O', 'O'],
 ['X', 'D', 'D', 'O']]

Output: 5
Explanation: Route is (0, 0), (0, 1), (1, 1), (2, 1), (2, 0), (3, 0) The minimum route takes 5 steps.

这道题目我当时一点思路也没有，后来看到答案之后，debug跟了一遍，有了些思路，以后再遇到，能有一个前进的方向了。

参考答案：

public class Demo{
    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    
    public static int minSteps(char[][] grid) {
        Queue<Point> q = new ArrayDeque<>();
        q.add(new Point(0, 0));
        grid[0][0] = 'D'; // mark as visited
        for (int steps = 1; !q.isEmpty(); steps++) {
            for (int sz = q.size(); sz > 0; sz--) {
                Point p = q.poll();
            
                for (int[] dir : DIRS) {
                    int r = p.r + dir[0];
                    int c = p.c + dir[1];
                    
                    if (isSafe(grid, r, c)) {
                        if (grid[r][c] == 'X') return steps;
                        grid[r][c] = 'D';
                        q.add(new Point(r, c));
                    }
                }
            }
        }
        return -1;
    }
    
    private static boolean isSafe(char[][] grid, int r, int c) {
        return r >= 0 && r < grid.length && c >= 0 && c < grid[0].length && grid[r][c] != 'D';
    }
    
    private static class Point {
        int r, c;
        Point(int r, int c) {
            this.r = r;
            this.c = c;
        }
    }
    
    public static void main(String[] args) {
        char[][] grid = {{'O', 'O', 'O', 'O'},
                         {'D', 'O', 'D', 'O'},
                         {'O', 'O', 'O', 'O'},
                         {'X', 'D', 'D', 'O'}};
        System.out.println(minSteps(grid));
    }
}

四、Two sum

题目：

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

解决方法：
第一种（大多数人都想到这种方法，思路简单，但是复杂度较高）：

class Solution {

    public int[] twoSum(int[] nums, int target) {
        for (int i = 0, len = nums.length; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[] { i, j };
                }
            }
        }
        return new int[] { 0, 0 };
    }
}

   第二种（复杂度最低，思路上绕了个弯子，接着HashMap）：

public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }

 三、LRU实现方式

思路：hashMap + 双向链表（因为双向链表，算法复杂度低）

代码如下：

public class Node<K, V> {
    Node<K, V> prev;
    Node<K, V> next;
    K k;
    V v;

    public Node(K k, V v) {
        this.k = k;
        this.v = v;
    }
}

public class LRUCache<K, V> {

    Node<K, V> head;
    Node<K, V> tail;
    HashMap<K, Node<K, V>> map;
    int capacity;

    public LRUCache(int capacity) {
        map = new HashMap<K, Node<K, V>>();
        this.capacity = capacity;
    }

    public V get(K key) {
        Node<K, V> node = map.get(key);
        if (node == null) {
            return null;
        }
        V value = node.v;
        // move node to tail
        removeNode(node);
        offerNode(node);
        return value;
    }

    public void put(K key, V value) {
        if (map.containsKey(key)) {
            Node<K, V> node = map.get(key);
            node.v = value;

            // move node to tail
            removeNode(node);
            offerNode(node);
        } else {

            // add to tail
            Node<K, V> node = new Node<K, V>(key, value);
            offerNode(node);
            map.put(key, node);

            if (map.size() > capacity) {
                map.remove(head.k);
                removeNode(head);
            }
        }
    }

    private void removeNode(Node<K, V> node) {
        if (node.prev != null) {
            node.prev.next = node.next;
        } else {
            head = node.next;
        }

        if (node.next != null) {
            node.next.prev = node.prev;
        } else {
            tail = node.prev;
        }
    }

    /*
     * move node to tail
     */
    private void offerNode(Node<K, V> node) {
        if (tail != null) {
            tail.next = node;
        }
        node.prev = tail;
        node.next = null;
        tail = node;

        if (head == null) {
            head = tail;
        }
    }

}

一、字符串反转

input：“abcde”

output:"edcba"

解决方案：

从后往前，一个个放入到新的char 数组

public String forReverse(String original) {
        char[] temp = original.toCharArray();
        StringBuffer sb = new StringBuffer();
        int tempLenth = temp.length;
        for (int i = tempLenth - 1; i >= 0; i--) {
            sb.append(temp[i]);
        }
        return sb.toString();

    }

两端同时交换（从两边到中间）

        String input = "Hello world"; 
        char[] temparray = input.toCharArray(); 
        int left, right=0; 
        right = temparray.length-1; 
  
        for (left=0; left < right ; left++ ,right--) 
 7         { 
 8             // Swap values of left and right 
 9             char temp = temparray[left]; 
10             temparray[left] = temparray[right]; 
11             temparray[right]=temp; 
12         } 
  
        for (char c : temparray) 
            System.out.print(c); 

两端同时交换（从中间到两端）

public String forReverse2(String original) {
        char[] value = original.toCharArray();
        int count = value.length;
        int n = count - 1;
        for (int j = (n - 1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;

        }
        return String.copyValueOf(value);
    }

二、字母排序

题目：给定一个字符串（里面全是大写字母，从A到Z,可以重复），如“CAEEFDK”。让你从新进行排序。

要求：

①必须以辅音字母开头（元音字母为：A、E、I、O、U，其余的字母全是辅音字母）

②2个辅音字母不可以连续放在一起

③2个元音字母不可以连续放在一起

求，给定一个字符串后，对它进行重排，那么可以有多少种组合？

例子：

给定字符串“AAA”，组合数为0

给定字符串“ABEK”，组合数为4

解题算法如下（我自己想到的算法，正确与否，有兴趣的朋友一起探讨）：

class Solution {
    public int solution(String S) {
        int sum = 1;
        // null check
        if (S == null || S.length() == 0) {
            return 0;
        }

        // Divide into two groups
        StringBuilder vowel = new StringBuilder();
        StringBuilder consonant = new StringBuilder();
        char[] original = S.toCharArray();
        for (char temp : original) {
            if (temp == 'A' || temp == 'E' || temp == 'I' || temp == 'O' || temp == 'U') {
                vowel.append(temp);
            } else {
                consonant.append(temp);
            }
        }

        // All vowels
        String vowelS = vowel.toString();
        String consonantS = consonant.toString();
        if (consonantS.length() == 0) {
            return 0;
        }

        // vowelS length
        int countVowel = vowelS.length();
        // consonantS length
        int countconsonant = consonantS.length();
        if ((countconsonant - countVowel) != 1 && countVowel != countconsonant) {
            return 0;
        }

        int countSamll = countVowel < countconsonant ? countVowel : countconsonant;

        for (int i = 0; i < countSamll; i++, countconsonant--, countVowel--) {
            sum = sum * countconsonant * countVowel;
        }
        return sum;
    }
}

解题思路，我就不说了，代码里写了，不明白的地方，大家相互探讨！如有不正之处，望指点。