half the memory for a point set

Author: h908714124

src/main/java/com/bernd/game/PointQueue.java

@@ -1,35 +1,62 @@
 package com.bernd.game;
 
+import static com.bernd.util.Util.divideUp;
+
 final class PointQueue {
 
+  private static final int LO = 0xffff;
+  private static final int HI = 0xffff0000;
+
+  private final int capacity;
+  private final int dim;
+
   private int write;
   private int read;
-  private final int dim;
   private final int[] buffer;
 
-  private PointQueue(int dim, int[] buffer) {
+  private PointQueue(
+      int capacity,
+      int dim,
+      int[] buffer) {
+    this.capacity = capacity;
     this.dim = dim;
     this.buffer = buffer;
   }
 
   static PointQueue create(int dim) {
-    // Assumption: All algorithms proceed from the starting point outward in a diamond shape.
-    // The circumference of the diamond shape is not greater than 2 * dim.
-    return new PointQueue(dim, new int[2 * dim + 1]);
+    // Assumption 1: All algorithms proceed from the starting point outward in a diamond shape.
+    // Assumption 2: The circumference of the diamond shape is not greater than 2 * dim + 1.
+    int capacity = 2 * dim + 1;
+    return new PointQueue(capacity, dim, new int[divideUp(capacity, 2)]);
   }
 
   void offer(int x, int y) {
-    buffer[write] = dim * y + x;
-    write = (write + 1) % buffer.length;
+    int ptId = dim * y + x;
+    set(ptId);
+    write = (write + 1) % capacity;
     if (write == read) {
       throw new RuntimeException("buffer overflow");
     }
   }
 
   int poll() {
-    int result = buffer[read];
-    read = (read + 1) % buffer.length;
-    return result;
+    int ptId = get();
+    read = (read + 1) % capacity;
+    return ptId;
+  }
+
+  private int get() {
+    int code = buffer[read / 2];
+    return read % 2 == 0 ? code & LO : (code >> 16);
+  }
+
+  private void set(int ptId) {
+    int pos = write / 2;
+    if (write % 2 == 0) {
+      buffer[pos] = (buffer[pos] & HI) | ptId;
+    } else {
+      buffer[pos] = (ptId << 16) | (buffer[pos] & LO);
+    }
   }
 
   boolean isEmpty() {

src/main/java/com/bernd/game/PointSet.java

@@ -1,5 +1,7 @@
 package com.bernd.game;
 
+import static com.bernd.util.Util.divideUp;
+
 final class PointSet {
 
   private final int dim;
@@ -11,22 +13,20 @@ private PointSet(int dim, int[] points) {
   }
 
   static PointSet create(int dim) {
-    return new PointSet(dim, new int[1 + ((dim * dim) / 16)]);
+    return new PointSet(dim, new int[divideUp(dim * dim, 0x11)]);
   }
 
   void add(int x, int y) {
     int ptId = y * dim + x;
-    int base = ptId / 16;
-    int off = ptId % 16;
-    int shift = 1 << off;
-    points[base] = points[base] | shift;
+    int pos = ptId >> 5;
+    int test = 1 << (ptId & 0x1f);
+    points[pos] = points[pos] | test;
   }
 
   boolean has(int x, int y) {
     int ptId = y * dim + x;
-    int base = ptId / 16;
-    int off = ptId % 16;
-    int shift = 1 << off;
-    return (points[base] & shift) != 0;
+    int pos = ptId >> 5;
+    int test = 1 << (ptId & 0x1f);
+    return (points[pos] & test) != 0;
   }
 }

src/main/java/com/bernd/util/BoardUpdate.java

@@ -6,7 +6,8 @@
 
 public class BoardUpdate implements Function<int[][], int[][]> {
 
-  private static final int SHIFT = 256; // > max(B, W)
+  private static final int LO = 0xffff;
+
   private int pos;
   private final int dim;
   private int[] updates;
@@ -38,7 +39,7 @@ public void add(int x, int y, int value) {
       updates = Arrays.copyOf(updates, dim * dim);
     }
     int ptId = dim * y + x;
-    updates[pos] = SHIFT * ptId + value;
+    updates[pos] = (value << 16) | ptId;
     pos++;
   }
 
@@ -52,13 +53,13 @@ public void add(Point point, int value) {
 
   public int x(int i) {
     int code = updates[i];
-    int ptId = code / SHIFT;
+    int ptId = code & LO;
     return ptId % dim;
   }
 
   public int y(int i) {
     int code = updates[i];
-    int ptId = code / SHIFT;
+    int ptId = code & LO;
     return ptId / dim;
   }
 
@@ -71,8 +72,8 @@ public int[][] apply(int[][] board) {
     int[][] result = Arrays.copyOf(board, board.length);
     for (int i = 0; i < pos; i++) {
       int code = updates[i];
-      int value = code % SHIFT;
-      int ptId = code / SHIFT;
+      int value = code >> 16;
+      int ptId = code & LO;
       int x = ptId % dim;
       int y = ptId / dim;
       if (result[y] == board[y]) {

src/main/java/com/bernd/util/Util.java

@@ -16,4 +16,8 @@ public static String boardToString(int[][] board) {
     sb.append("};");
     return sb.toString();
   }
+
+  public static int divideUp(int i, int div) {
+    return i % div == 0 ? i / div : (i / div) + 1;
+  }
 }

src/test/java/com/bernd/game/CountTest.java

@@ -10,8 +10,8 @@
 
 class CountTest {
 
-  private static final int C = B + TERRITORY;
-  private static final int X = W + TERRITORY;
+  private static final int b = B + TERRITORY;
+  private static final int w = W + TERRITORY;
 
   @Test
   void testRemoveOneStone() {
@@ -39,11 +39,11 @@ void testCountBlackTerritory() {
     };
     int[][] result = Count.count(position);
     assertArrayEquals(new int[][]{
-        new int[]{C, C, C, C, C},
-        new int[]{C, B, B, B, C},
-        new int[]{C, B, C, B, C},
-        new int[]{C, B, B, B, C},
-        new int[]{C, C, C, C, C},
+        new int[]{b, b, b, b, b},
+        new int[]{b, B, B, B, b},
+        new int[]{b, B, b, B, b},
+        new int[]{b, B, B, B, b},
+        new int[]{b, b, b, b, b},
     }, result);
   }
 
@@ -57,10 +57,10 @@ void testCountFull() {
     };
     int[][] result = Count.count(position);
     assertArrayEquals(new int[][]{
-        new int[]{C, C, C, C},
+        new int[]{b, b, b, b},
         new int[]{B, B, B, B},
         new int[]{W, W, W, W},
-        new int[]{X, X, X, X},
+        new int[]{w, w, w, w},
     }, result);
   }
 
@@ -77,7 +77,7 @@ void testCountPartial() {
         new int[]{0, W, 0, 0},
         new int[]{B, B, B, B},
         new int[]{W, W, W, W},
-        new int[]{X, X, X, X},
+        new int[]{w, w, w, w},
     }, result);
   }
 
@@ -95,12 +95,12 @@ void testMarkBig() {
         new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0},
     };
     int[][] acc = Count.createAcc(position);
-    acc[0] = new int[]{B, C, B, B, B, W, -1, -1, -1};
+    acc[0] = new int[]{B, b, B, B, B, W, -1, -1, -1};
     acc[1] = new int[]{B, B, B, W, W, B, -1, -1, -1};
     acc[2] = new int[]{W, W, W, W, -1, -1, -1, -1, -1};
     Count.markStonesAround(acc, position, 6, 0);
     assertArrayEquals(new int[][]{
-        new int[]{B, C, B, B, B, W, 0, 0, 0},
+        new int[]{B, b, B, B, B, W, 0, 0, 0},
         new int[]{B, B, B, W, W, B, 0, 0, 0},
         new int[]{W, W, W, W, 0, 0, 0, 0, 0},
         new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -128,7 +128,7 @@ void testMarkSmall() {
     int[][] acc = Count.createAcc(position);
     acc[0][0] = B;
     Count.markStonesAround(acc, position, 1, 0);
-    assertArrayEquals(new int[]{B, C, -1, -1, -1, -1, -1, -1, -1}, acc[0]);
+    assertArrayEquals(new int[]{B, b, -1, -1, -1, -1, -1, -1, -1}, acc[0]);
   }
 
   @Test
@@ -146,7 +146,7 @@ void testCountLargeArea() {
     };
     int[][] result = Count.count(position);
     assertArrayEquals(new int[][]{
-        new int[]{B, C, B, B, B, W, 0, 0, 0},
+        new int[]{B, b, B, B, B, W, 0, 0, 0},
         new int[]{B, B, B, W, W, B, 0, 0, 0},
         new int[]{W, W, W, W, 0, 0, 0, 0, 0},
         new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0},

src/test/java/com/bernd/game/PointSetTest.java

@@ -8,7 +8,7 @@
 class PointSetTest {
 
   @Test
-  void add() {
+  void testSmall() {
     PointSet pointSet = PointSet.create(2);
     pointSet.add(0, 1);
     pointSet.add(1, 1);
@@ -17,4 +17,15 @@ void add() {
     assertFalse(pointSet.has(1, 0));
     assertTrue(pointSet.has(1, 1));
   }
+
+  @Test
+  void testBig() {
+    PointSet pointSet = PointSet.create(19);
+    pointSet.add(10, 10);
+    assertFalse(pointSet.has(9, 10));
+    assertFalse(pointSet.has(10, 9));
+    assertTrue(pointSet.has(10, 10));
+    assertFalse(pointSet.has(10, 11));
+    assertFalse(pointSet.has(11, 10));
+  }
 }