190901

Author: csf0630p

136_Single Number.java

@@ -0,0 +1,7 @@
+class Solution {
+    public int singleNumber(int[] nums) {
+        int res = 0;
+        for (Integer e : nums) res ^= e;
+        return res;        
+    }
+}

190_Reverse Bits.java

@@ -0,0 +1,53 @@
+// 1.0
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        int res = 0;
+        for (int i = 0; i < 32; i++) {
+            res <<= 1;
+            res |= (n & 1);
+            n >>>= 1;
+        }
+        return res;        
+    }
+}
+
+// 1.1 将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接
+private static Map<Byte, Integer> cache = new HashMap<>();
+
+public int reverseBits(int n) {
+    int ret = 0;
+    for (int i = 0; i < 4; i++) {
+        ret <<= 8;
+        ret |= reverseByte((byte) (n & 0b11111111));
+        n >>= 8;
+    }
+    return ret;
+}
+
+private int reverseByte(byte b) {
+    if (cache.containsKey(b)) return cache.get(b);
+    int ret = 0;
+    byte t = b;
+    for (int i = 0; i < 8; i++) {
+        ret <<= 1;
+        ret |= t & 1;
+        t >>= 1;
+    }
+    cache.put(b, ret);
+    return ret;
+}
+
+// 1.2
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+            int ret=n;
+            ret = ret >>> 16 | ret<<16;
+            ret = (ret & 0xff00ff00) >>> 8 | (ret & 0x00ff00ff) << 8;
+            ret = (ret & 0xf0f0f0f0) >>> 4 | (ret & 0x0f0f0f0f) << 4;
+            ret = (ret & 0xcccccccc) >>> 2 | (ret & 0x33333333) << 2;
+            ret = (ret & 0xaaaaaaaa) >>> 1 | (ret & 0x55555555) << 1;
+            return ret;
+    }
+}

231_Power of Two.java

@@ -0,0 +1,6 @@
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        return n > 0 && (n == (n & -n));
+        return n > 0 && (n & (n - 1)) == 0;    		
+    }
+}

260_Single Number III.java

@@ -0,0 +1,23 @@
+class Solution {
+    public int[] singleNumber(int[] nums) {
+        int diff = 0;
+        for (int num : nums) diff ^= num;
+        diff &= -diff;  // diff &= -diff 得到出 diff 最右侧不为 0 的位
+		// int lastBit = (aXorb & (aXorb - 1)) ^ aXorb;  // the last bit that a diffs b
+        int[] res = new int[2];
+        for (int num : nums) {
+            if ((num & diff) == 0) res[0] ^= num;
+            else res[1] ^= num;
+        }
+        return res;
+    }
+}
+0101 d 
+1010 1's comp 
+1011 2's comp 
+0001 last digit
+
+0101 d
+0100 d-1
+0100 d & d-1
+0001 last digit

342_Power of Four.java

@@ -0,0 +1,14 @@
+class Solution {
+    public boolean isPowerOfFour(int num) {
+        return Integer.toString(num, 4).matches("10*");
+		
+        return num > 0 && (num & (num - 1)) == 0 && (num - 1) % 3 == 0;
+		// 4^n - 1 = (2^n + 1) * (2^n - 1), among (2^n-1), (2^n), (2^n+1), one of them must be a multiple of 3, and (2^n) cannot be the one, so (4^n - 1) % 3 == 0
+		// only prove ((4-1)^n - 1)%3 ==0 is not enough, you also need to prove that (2^n-1)%3 != 0 when n is odd.
+		// 2^n = (3-1)^n = C(n,0)3^n(-1)^0+....+(-1)^n.
+		// 1.When 2^n is 4^n, which means n is even, in this case, (-1)^n==1 and (2^n-1）%3==0
+		// 2.When 2&n is not 4^n, which means n is odd, in this case, (-1)^n=-1 and (2^n-1）%3==1；
+		
+		return (num > 0) && ((num & (num - 1)) == 0) && ((num & 0x55555555) == num);
+    }
+}

461_Hamming Distance.java

@@ -0,0 +1,10 @@
+class Solution {
+    public int hammingDistance(int x, int y) {
+        int temp = x ^ y, res = 0;
+        while (temp > 0) {
+            res += temp & 1;
+            temp >>= 1;
+        }
+        return res;
+    }
+}

714_Best Time to Buy and Sell Stock with Transaction Fee.java

@@ -0,0 +1,49 @@
+// 1.0 DP, O(n)/O(n)
+// Soldi=Max(Soldi−1,Holdi−1+Pricesi−fee); Holdi=Max(Holdi,Soldi−1−Pricesi)
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        int n = prices.length;
+        // if (n < 2) return 0;
+        int[] sold = new int[n];
+        int[] hold = new int[n];
+        hold[0] = -prices[0];
+        for (int i = 1; i < n; i++){
+            sold[i] = Math.max(sold[i-1], hold[i-1] + prices[i] - fee);
+            hold[i] = Math.max(hold[i-1], sold[i-1] - prices[i]);
+        }
+        return sold[n-1];        
+    }
+}
+
+// 1.1 DP, O(n)/O(1)
+    public int maxProfit(int[] prices, int fee) {
+        int n = prices.length;
+        int sold = 0;
+        int hold = -prices[0];
+        for (int i = 1; i < n; i++){
+            int soldpre = sold;
+            sold = Math.max(soldpre, hold + prices[i] - fee);
+            hold = Math.max(hold, soldpre - prices[i]);
+        }
+        return sold;
+    }
+	
+// 2.0 Greedy, O(n)/O(1)
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        int profit=0, curProfit=0;
+        int minP=prices[0], maxP=prices[0];
+        for(int i=1;i<prices.length;i++){
+            minP = Math.min(minP,prices[i]);
+            maxP = Math.max(maxP,prices[i]);
+            curProfit = Math.max(curProfit,prices[i]-minP-fee);
+            if((maxP-prices[i])>=fee){//can just sell the stock at maxP day.
+                profit += curProfit;
+                curProfit = 0;
+                minP = prices[i];
+                maxP = prices[i];
+            }
+        }
+        return profit + curProfit;
+    }
+}

797_All Paths From Source to Target.java

@@ -0,0 +1,27 @@
+// 1.0 dfs
+class Solution {
+    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {     
+        List<List<Integer>> res = new LinkedList<List<Integer>>();
+        if (graph == null || graph.length == 0) return res;
+        Stack<Integer> path = new Stack<Integer>();
+        path.push(0);
+        dfs(graph, 0, res, path);
+        return res;
+    }
+    
+    void dfs(int[][] graph, int cur, List<List<Integer>> res, Stack<Integer> path) {
+        int n = graph.length;
+        if (cur == n - 1) {
+            res.add(new ArrayList<Integer>(path));
+        } else {
+            for (int i = 0; i < graph[cur].length; i++) {
+                path.push(graph[cur][i]);
+                dfs(graph, graph[cur][i], res, path);
+                path.pop();
+            }
+        }
+    }
+}
+
+//2.0 bfs
+//http://www.ciaoshen.com/algorithm/leetcode/2019/03/20/leetcode-all-paths-from-source-to-target.html