ST work

Author: williamfiset

slides/datastructures/sparse_table/sparse_table.key

@@ -38,6 +38,7 @@ public enum Operation {
     MIN,
     MAX,
     SUM,
+    MULT,
     GCD
   };
 
@@ -47,6 +48,7 @@ public enum Operation {
   private BinaryOperator<Long> sumFn = (a, b) -> a + b;
   private BinaryOperator<Long> minFn = (a, b) -> Math.min(a, b);
   private BinaryOperator<Long> maxFn = (a, b) -> Math.max(a, b);
+  private BinaryOperator<Long> multFn = (a, b) -> a * b;
   private BinaryOperator<Long> gcdFn =
       (a, b) -> {
         long gcd = a;
@@ -106,6 +108,8 @@ private void init(long[] v) {
           }
         } else if (op == Operation.SUM) {
           dp[i][j] = sumFn.apply(leftInterval, rightInterval);
+        } else if (op == Operation.MULT) {
+          dp[i][j] = multFn.apply(leftInterval, rightInterval);
         } else if (op == Operation.GCD) {
           dp[i][j] = gcdFn.apply(leftInterval, rightInterval);
         }
@@ -126,14 +130,21 @@ private void printTable() {
 
   // Queries [l, r] for the operation set on this sparse table.
   public long query(int l, int r) {
+    // Fast queries types, O(1)
     if (op == Operation.MIN) {
       return query(l, r, minFn);
     } else if (op == Operation.MAX) {
       return query(l, r, maxFn);
     } else if (op == Operation.GCD) {
       return query(l, r, gcdFn);
     }
-    return sumQuery(l, r);
+
+    // Slower query types, O(log2(n))
+    if (op == Operation.SUM) {
+      return sumQuery(l, r);
+    } else {
+      return multQuery(l, r);
+    }
   }
 
   public int queryIndex(int l, int r) {
@@ -148,7 +159,7 @@ public int queryIndex(int l, int r) {
 
   private int minQueryIndex(int l, int r) {
     int len = r - l + 1;
-    int p = log2[r - l + 1];
+    int p = log2[len];
     long leftInterval = dp[p][l];
     long rightInterval = dp[p][r - (1 << p) + 1];
     if (leftInterval <= rightInterval) {
@@ -160,7 +171,7 @@ private int minQueryIndex(int l, int r) {
 
   private int maxQueryIndex(int l, int r) {
     int len = r - l + 1;
-    int p = log2[r - l + 1];
+    int p = log2[len];
     long leftInterval = dp[p][l];
     long rightInterval = dp[p][r - (1 << p) + 1];
     if (leftInterval >= rightInterval) {
@@ -184,14 +195,25 @@ private long sumQuery(int l, int r) {
     for (int p = P; p >= 0; p--) {
       int rangeLength = r - l + 1;
       if ((1 << p) <= rangeLength) {
-        // System.out.printf("[%d, %d)\n", l, l + (1<<p));
         sum += dp[p][l];
         l += (1 << p);
       }
     }
     return sum;
   }
 
+  private long multQuery(int l, int r) {
+    long result = 1;
+    for (int p = P; p >= 0; p--) {
+      int rangeLength = r - l + 1;
+      if ((1 << p) <= rangeLength) {
+        result *= dp[p][l];
+        l += (1 << p);
+      }
+    }
+    return result;
+  }
+
   // Do either a min, max or gcd query on the interval [l, r] in O(1).
   //
   // We can get O(1) query by finding the smallest power of 2 that fits within the interval length
@@ -201,7 +223,7 @@ private long sumQuery(int l, int r) {
   // wrong result since it is not an idempotent binary function.
   private long query(int l, int r, BinaryOperator<Long> fn) {
     int len = r - l + 1;
-    int p = log2[r - l + 1];
+    int p = log2[len];
     return fn.apply(dp[p][l], dp[p][r - (1 << p) + 1]);
   }
 
@@ -217,27 +239,16 @@ private static void example1() {
     // Initialize sparse table to do range minimum queries.
     SparseTable sparseTable = new SparseTable(values, SparseTable.Operation.MIN);
 
-    // Prints: "Min value between [2, 7] = -1"
     System.out.printf("Min value between [2, 7] = %d\n", sparseTable.query(2, 7));
-
-    // Prints: "Index of min value between [2, 7] = 5". Returns the leftmost index in the
-    // event that there are duplicates.
-    System.out.printf("Index of min value between [2, 7] = %d\n", sparseTable.queryIndex(2, 7));
   }
 
   private static void example2() {
     long[] values = {4, 2, 3, 7, 1, 5, 3, 3, 9, 6, 7, -1, 4};
-    System.out.println(values.length);
 
     // Initialize sparse table to do range minimum queries.
     SparseTable sparseTable = new SparseTable(values, SparseTable.Operation.MIN);
 
-    // Prints: "Min value between [2, 7] = -1"
     System.out.printf("Min value between [2, 7] = %d\n", sparseTable.query(2, 7));
-
-    // Prints: "Index of min value between [2, 7] = 5". Returns the leftmost index in the
-    // event that there are duplicates.
-    // System.out.printf("Index of min value between [2, 7] = %d\n", sparseTable.queryIndex(2, 7));
   }
 
   private static void example3() {
@@ -247,11 +258,6 @@ private static void example3() {
     // Initialize sparse table to do range minimum queries.
     SparseTable sparseTable = new SparseTable(values, SparseTable.Operation.SUM);
 
-    // Prints: "Min value between [2, 7] = -1"
     System.out.printf("Min value between [5, 17] = %d\n", sparseTable.query(5, 17));
-
-    // Prints: "Index of min value between [5, 17] = 5". Returns the leftmost index in the
-    // event that there are duplicates.
-    // System.out.printf("Index of min value between [5, 17] = %d\n", sparseTable.queryIndex(2, 7));
   }
 }

src/main/java/com/williamfiset/algorithms/datastructures/sparsetable/SparseTable.java

@@ -15,9 +15,11 @@ private void queryResultTest(
       maxQuery(values, l, r, actual, index);
     } else if (op == SparseTable.Operation.SUM) {
       sumQuery(values, l, r, actual);
+    } else if (op == SparseTable.Operation.MULT) {
+      multQuery(values, l, r, actual);
     } else if (op == SparseTable.Operation.GCD) {
       gcdQuery(values, l, r, actual);
-    }
+    } 
   }
 
   private void minQuery(long[] values, int l, int r, long actual, int index) {
@@ -40,6 +42,12 @@ private void sumQuery(long[] values, int l, int r, long actual) {
     assertThat(m).isEqualTo(actual);
   }
 
+  private void multQuery(long[] values, int l, int r, long actual) {
+    long m = 1;
+    for (int i = l; i <= r; i++) m *= values[i];
+    assertThat(m).isEqualTo(actual);
+  }
+
   // Computes the Greatest Common Divisor (GCD) of a & b
   // This method ensures that the value returned is non negative
   public static long gcd(long a, long b) {
@@ -56,6 +64,7 @@ private void testAllOperations(long[] values) {
     SparseTable min_st = new SparseTable(values, SparseTable.Operation.MIN);
     SparseTable max_st = new SparseTable(values, SparseTable.Operation.MAX);
     SparseTable sum_st = new SparseTable(values, SparseTable.Operation.SUM);
+    SparseTable mult_st = new SparseTable(values, SparseTable.Operation.MULT);
     SparseTable gcd_st = new SparseTable(values, SparseTable.Operation.GCD);
 
     for (int i = 0; i < values.length; i++) {
@@ -66,6 +75,8 @@ private void testAllOperations(long[] values) {
             values, i, j, max_st.query(i, j), max_st.queryIndex(i, j), SparseTable.Operation.MAX);
         queryResultTest(
             values, i, j, sum_st.query(i, j), -1 /* unused */, SparseTable.Operation.SUM);
+        queryResultTest(
+            values, i, j, mult_st.query(i, j), -1 /* unused */, SparseTable.Operation.MULT);
         queryResultTest(
             values, i, j, gcd_st.query(i, j), -1 /* unused */, SparseTable.Operation.GCD);
       }