tic-tac-toe game, trapping the water

Author: JoshuaJiangFD

src/main/java/joshua/leetcode/array/twopointers/TrappingRainWater.java

@@ -2,7 +2,6 @@
 
 import joshua.leetcode.solutiontag.Stacks;
 import joshua.leetcode.solutiontag.TwoPointers;
-import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
 import java.util.Deque;
 import java.util.LinkedList;
@@ -20,21 +19,61 @@ public abstract class TrappingRainWater {
      * <p/>
      * compute how much water it is able to trap after raining.
      * <p/>
-     *
+     * <p/>
      * For example,
      * Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.
      *
-     * @param height
+     * @param height the array of heights.
      * @return
      */
     public abstract int trap(int[] height);
 
     @TwoPointers
     public static class Solution1 extends TrappingRainWater {
 
+        /**
+         * 双指针法的思路解释如下：
+         * left pointer和right pointer从两端向中间移动，肯定有一侧高，一侧低。这时候从低的一侧灌水肯定能trap住。
+         * 因此可以继续移动低的一侧的指针，同时判断移动的过程中能够trap的水量（小方块），直到到达最低点。
+         * 这时候再次判断left pointer和right pointer的大小。
+         * 直到两个指针相遇。
+         */
         @Override
         public int trap(int[] height) {
-            throw new NotImplementedException();
+            // can only trap water when length >= 3
+            if (height == null || height.length < 3) {
+                return 0;
+            }
+            int water = 0;
+            int leftPointer = 0;
+            int rightPointer = height.length - 1;
+            int maxLeft = 0;
+            int maxRight = 0;
+            // 结束条件
+            while (leftPointer < rightPointer) {
+                // 左低右高，计算左侧蓄水量
+                if (height[leftPointer] < height[rightPointer]) {
+                    // 无法继续蓄水，更新左侧Bar值
+                    if (maxLeft < height[leftPointer]) {
+                        maxLeft = height[leftPointer];
+                    } else {
+                        // 蓄水量
+                        water += maxLeft - height[leftPointer];
+                    }
+                    leftPointer++;
+                } else {
+                    // 左高右低，计算右侧需水量
+                    if (maxRight < height[rightPointer]) {
+                        // 无法继续蓄水，更新右侧Bar值
+                        maxRight = height[rightPointer];
+                    } else {
+                        // 蓄水量
+                        water += maxRight - height[rightPointer];
+                    }
+                    rightPointer--;
+                }
+            }
+            return water;
         }
     }
 
@@ -53,23 +92,18 @@ public int trap(int[] height) {
             Deque<Integer> stack = new LinkedList<Integer>();
             // stack stores the index of element.
             int water = 0;
-            stack.push(0);
-            for (int i = 1; i < height.length; i++) {
-                if(stack.isEmpty() || height[i] < height[stack.peek()]) {
+            for (int i = 0; i < height.length; i++) {
+                if (stack.isEmpty() || height[stack.peek()] >= height[i]) {
                     stack.push(i);
-                    continue;
-                }
-                int bottom = height[stack.pop()];
-                while (!stack.isEmpty()) {
-                    if ( height[stack.peek()] <= height[i]) {
-                        int idx = stack.pop();
-                        water += (i - idx - 1) * (height[idx] - bottom);
-                        bottom = height[idx];
-                    } else {
-                        break;
+                } else {
+                    int tmp = stack.pop();
+                    if (!stack.isEmpty()) {
+                        int heightVal = Math.min(height[stack.peek()], height[i]) - height[tmp];
+                        int widthVal = i - stack.peek() - 1;
+                        water += heightVal * widthVal;
                     }
+                    i--;
                 }
-                stack.push(i);
             }
             return water;
         }

src/main/java/joshua/leetcode/design/TicTacToe.java

@@ -0,0 +1,78 @@
+package joshua.leetcode.design;
+
+/**
+ * 348. Design Tic-Tac-Toe <br/>
+ * <p/>
+ * <a href = "https://leetcode.com/problems/design-tic-tac-toe/">leetcode link</a>
+ * <p/>
+ * Created by joshu on 2016/5/26.
+ */
+public abstract class TicTacToe {
+
+    /**
+     * Initialize your data structure here.
+     *
+     * @param n the length of column and row.
+     */
+    public TicTacToe(int n) {
+    }
+
+    /**
+     * Player {player} makes a move at ({row}, {col}).
+     *
+     * @param row    The row of the board.
+     * @param col    The column of the board.
+     * @param player The player, can be either 1 or 2.
+     * @return The current winning condition, can be either:
+     * 0: No one wins.
+     * 1: Player 1 wins.
+     * 2: Player 2 wins.
+     */
+    public abstract int move(int row, int col, int player);
+
+    public static class Solution1 extends TicTacToe {
+
+        int[] rows;
+        int[] columns;
+        int n;
+        int diagonal;
+        int antiDiagonal;
+
+        public Solution1(int n) {
+            super(n);
+            rows = new int[n];
+            columns = new int[n];
+            this.n = n;
+        }
+
+        /**
+         * X 表示 play 1. player 1赢棋。
+         * |X| |O|
+         * |O|O| |
+         * |X|X|X|
+         *
+         * 如果用 col[3]和row[3]表示每个点在两个轴的投影，可以得出结论最后一行全是X，所以row[2] == 3。
+         * 因此可以用两个数组记录每次下棋在两个轴上的投影，X表示-1, O表示1.任意一个轴上某个位置的值等于3或者-3
+         * 就表示当前棋手赢了。
+         * 另外需要两个变量保存对角线和斜对角线上的值得累加。
+         *
+         */
+        @Override
+        public int move(int row, int col, int player) {
+            int val = player == 1 ? 1 : -1;
+            rows[row] += val;
+            if (rows[row] == n * val) return player;
+            columns[col] += val;
+            if (columns[col] == n * val) return player;
+            if (row == col) {
+                diagonal += val;
+                if (diagonal == n * val) return player;
+            }
+            if (row + col == n - 1) {
+                antiDiagonal += val;
+                if (antiDiagonal == n * val) return player;
+            }
+            return 0;
+        }
+    }
+}

src/test/java/joshua/leetcode/array/twopointers/TrappingRainWaterTest.java

@@ -25,4 +25,12 @@ public void testSolution2() {
 		}
 	}
 
+	@Test
+	public void testSolution1() {
+		TrappingRainWater sol=new TrappingRainWater.Solution1();
+		for (int[] key : cases.keySet()) {
+			assertEquals((int)cases.get(key), sol.trap(key));
+		}
+	}
+
 }