五、寻找宝藏
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跟了一遍，有了些思路，以后再遇到，能有一个前进的方向了。
参考答案：
1 public class Demo{ 2 private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; 3 4 public static int minSteps(char[][] grid) { 5 Queue<Point> q = new ArrayDeque<>(); 6 q.add(new Point(0, 0)); 7 grid[0][0] = 'D'; // mark as visited 8 for (int steps = 1; !q.isEmpty(); steps++) { 9 for (int sz = q.size(); sz > 0; sz--) { 10 Point p = q.poll(); 11 12 for (int[] dir : DIRS) { 13 int r = p.r + dir[0]; 14 int c = p.c + dir[1]; 15 16 if (isSafe(grid, r, c)) { 17 if (grid[r][c] == 'X') return steps; 18 grid[r][c] = 'D'; 19 q.add(new Point(r, c)); 20 } 21 } 22 } 23 } 24 return -1; 25 } 26 27 private static boolean isSafe(char[][] grid, int r, int c) { 28 return r >= 0 && r < grid.length && c >= 0 && c < grid[0].length && grid[r][c] != 'D'; 29 } 30 31 private static class Point { 32 int r, c; 33 Point(int r, int c) { 34 this.r = r; 35 this.c = c; 36 } 37 } 38 39 public static void main(String[] args) { 40 char[][] grid = {{'O', 'O', 'O', 'O'}, 41 {'D', 'O', 'D', 'O'}, 42 {'O', 'O', 'O', 'O'}, 43 {'X', 'D', 'D', 'O'}}; 44 System.out.println(minSteps(grid)); 45 } 46 }
四、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].
解决方法：
第一种（大多数人都想到这种方法，思路简单，但是复杂度较高）：
1 class Solution { 2 3 public int[] twoSum(int[] nums, int target) { 4 for (int i = 0, len = nums.length; i < len; i++) { 5 for (int j = i + 1; j < len; j++) { 6 if (nums[i] + nums[j] == target) { 7 return new int[] { i, j }; 8 } 9 } 10 } 11 return new int[] { 0, 0 }; 12 } 13 }
第二种（复杂度最低，思路上绕了个弯子，接着HashMap）：
1 public int[] twoSum(int[] nums, int target) { 2 Map<Integer, Integer> map = new HashMap<>(); 3 for (int i = 0; i < nums.length; i++) { 4 int complement = target - nums[i]; 5 if (map.containsKey(complement)) { 6 return new int[] { map.get(complement), i }; 7 } 8 map.put(nums[i], i); 9 } 10 throw new IllegalArgumentException("No two sum solution"); 11 }
三、LRU实现方式
思路：hashMap + 双向链表（因为双向链表，算法复杂度低）
代码如下：
1 public class Node<K, V> { 2 Node<K, V> prev; 3 Node<K, V> next; 4 K k; 5 V v; 6 7 public Node(K k, V v) { 8 this.k = k; 9 this.v = v; 10 } 11 }
1 public class LRUCache<K, V> { 2 3 Node<K, V> head; 4 Node<K, V> tail; 5 HashMap<K, Node<K, V>> map; 6 int capacity; 7 8 public LRUCache(int capacity) { 9 map = new HashMap<K, Node<K, V>>(); 10 this.capacity = capacity; 11 } 12 13 public V get(K key) { 14 Node<K, V> node = map.get(key); 15 if (node == null) { 16 return null; 17 } 18 V value = node.v; 19 // move node to tail 20 removeNode(node); 21 offerNode(node); 22 return value; 23 } 24 25 public void put(K key, V value) { 26 if (map.containsKey(key)) { 27 Node<K, V> node = map.get(key); 28 node.v = value; 29 30 // move node to tail 31 removeNode(node); 32 offerNode(node); 33 } else { 34 35 // add to tail 36 Node<K, V> node = new Node<K, V>(key, value); 37 offerNode(node); 38 map.put(key, node); 39 40 if (map.size() > capacity) { 41 map.remove(head.k); 42 removeNode(head); 43 } 44 } 45 } 46 47 private void removeNode(Node<K, V> node) { 48 if (node.prev != null) { 49 node.prev.next = node.next; 50 } else { 51 head = node.next; 52 } 53 54 if (node.next != null) { 55 node.next.prev = node.prev; 56 } else { 57 tail = node.prev; 58 } 59 } 60 61 /* 62 * move node to tail 63 */ 64 private void offerNode(Node<K, V> node) { 65 if (tail != null) { 66 tail.next = node; 67 } 68 node.prev = tail; 69 node.next = null; 70 tail = node; 71 72 if (head == null) { 73 head = tail; 74 } 75 } 76 77 }
一、字符串反转
input：“abcde”
output:"edcba"
解决方案：
从后往前，一个个放入到新的char 数组
1 public String forReverse(String original) { 2 char[] temp = original.toCharArray(); 3 StringBuffer sb = new StringBuffer(); 4 int tempLenth = temp.length; 5 for (int i = tempLenth - 1; i >= 0; i--) { 6 sb.append(temp[i]); 7 } 8 return sb.toString(); 9 10 }
两端同时交换（从两边到中间）
1 String input = "Hello world"; 2 char[] temparray = input.toCharArray(); 3 int left, right=0; 4 right = temparray.length-1; 5 6 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 } 13 14 for (char c : temparray) 15 System.out.print(c);
两端同时交换（从中间到两端）
1 public String forReverse2(String original) { 2 char[] value = original.toCharArray(); 3 int count = value.length; 4 int n = count - 1; 5 for (int j = (n - 1) >> 1; j >= 0; j--) { 6 int k = n - j; 7 char cj = value[j]; 8 char ck = value[k]; 9 value[j] = ck; 10 value[k] = cj; 11 12 } 13 return String.copyValueOf(value); 14 }
二、字母排序
题目：给定一个字符串（里面全是大写字母，从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; } }
解题思路，我就不说了，代码里写了，不明白的地方，大家相互探讨！如有不正之处，望指点。
补充中。。。2019/06/10更新