⚡ improve: optimize gomoku

Author: guanghechen

Diff for: .vscode/settings.json

@@ -1,5 +1,6 @@
 {
   "cSpell.words": [
+    "ccrf",
     "codeforces",
     "deno",
     "Dinic",
@@ -16,6 +17,7 @@
     "mcmf",
     "mincost",
     "mincut",
+    "mwps",
     "nums",
     "Parens",
     "pinst",

Diff for: packages/gomoku/__test__/count-map.spec.ts

@@ -2,7 +2,6 @@ import fs from 'fs-extra'
 import { locateFixtures } from 'jest.setup'
 import type { GomokuDirectionType, IGomokuContextProps, IGomokuPiece } from '../src'
 import { GomokuContext, GomokuCountMap, GomokuDirectionTypes } from '../src'
-import { PieceDataDirName, locatePieceDataFilepaths } from './util'
 
 const { rightHalf: halfDirectionTypes } = GomokuDirectionTypes
 
@@ -103,8 +102,8 @@ describe('15x15', () => {
         expect(tester.candidateCouldReachFinal(1, posId)).toEqual(
           tester.$candidateCouldReachFinal(1, posId),
         )
-        expect(Array.from(tester.mustDropPos(0)).length).toEqual(tester.$stateCouldReachFinal(0))
-        expect(Array.from(tester.mustDropPos(1)).length).toEqual(tester.$stateCouldReachFinal(1))
+        expect(Array.from(tester.mustWinPosSet(0)).length).toEqual(tester.$stateCouldReachFinal(0))
+        expect(Array.from(tester.mustWinPosSet(1)).length).toEqual(tester.$stateCouldReachFinal(1))
       }
       for (let posId = 0; posId < tester.context.TOTAL_POS; ++posId) {
         expect(tester.candidateCouldReachFinal(0, posId)).toEqual(
@@ -113,8 +112,8 @@ describe('15x15', () => {
         expect(tester.candidateCouldReachFinal(1, posId)).toEqual(
           tester.$candidateCouldReachFinal(1, posId),
         )
-        expect(Array.from(tester.mustDropPos(0)).length).toEqual(tester.$stateCouldReachFinal(0))
-        expect(Array.from(tester.mustDropPos(1)).length).toEqual(tester.$stateCouldReachFinal(1))
+        expect(Array.from(tester.mustWinPosSet(0)).length).toEqual(tester.$stateCouldReachFinal(0))
+        expect(Array.from(tester.mustWinPosSet(1)).length).toEqual(tester.$stateCouldReachFinal(1))
       }
     }
   })

Diff for: packages/gomoku/__test__/solution.spec.ts

@@ -29,15 +29,17 @@ describe('15x15', function () {
     const solution = getSolution()
     solution.init([])
     solution.forward(7, 7, 0)
-    const [r, c] = solution.minimaxSearch(1)
+    let [r, c] = solution.minimaxSearch(1)
     expect(Math.abs(r - 7)).toBeLessThanOrEqual(2)
     expect(Math.abs(c - 7)).toBeLessThanOrEqual(2)
 
     solution.forward(6, 6, 1)
+    ;[r, c] = solution.minimaxSearch(0)
     expect(Math.abs(r - 7)).toBeLessThanOrEqual(3)
     expect(Math.abs(c - 7)).toBeLessThanOrEqual(3)
 
     solution.forward(6, 7, 0)
+    ;[r, c] = solution.minimaxSearch(1)
     expect(Math.abs(r - 7)).toBeLessThanOrEqual(3)
     expect(Math.abs(c - 7)).toBeLessThanOrEqual(3)
   })

Diff for: packages/gomoku/__test__/state.spec.ts

@@ -94,14 +94,14 @@ class TestHelper extends GomokuState {
         if (context.hasPlacedNeighbors(id)) candidateSet.add(id)
       }
     }
-    if (countMap.mustDropPos(nextPlayerId)) {
+    if (countMap.mustWinPosSet(nextPlayerId).size > 0) {
       for (const posId of _candidateSet) {
         if (countMap.candidateCouldReachFinal(nextPlayerId, posId)) {
           return [posId]
         }
       }
     }
-    if (countMap.mustDropPos(nextPlayerId ^ 1)) {
+    if (countMap.mustWinPosSet(nextPlayerId ^ 1).size > 0) {
       const playerId: number = nextPlayerId ^ 1
       for (const posId of _candidateSet) {
         if (countMap.candidateCouldReachFinal(playerId, posId)) {
@@ -128,14 +128,14 @@ class TestHelper extends GomokuState {
   public $getCandidates(nextPlayerId: number, minMultipleOfTopScore: number): IGomokuCandidate[] {
     const { countMap, _candidateSet } = this
 
-    if (countMap.mustDropPos(nextPlayerId)) {
+    if (countMap.mustWinPosSet(nextPlayerId).size > 0) {
       for (const posId of _candidateSet) {
         if (countMap.candidateCouldReachFinal(nextPlayerId, posId)) {
           return [{ posId, score: Number.MAX_VALUE }]
         }
       }
     }
-    if (countMap.mustDropPos(nextPlayerId ^ 1)) {
+    if (countMap.mustWinPosSet(nextPlayerId ^ 1).size > 0) {
       const playerId: number = nextPlayerId ^ 1
       for (const posId of _candidateSet) {
         if (countMap.candidateCouldReachFinal(playerId, posId)) {

Diff for: packages/gomoku/src/context.ts

@@ -1,7 +1,7 @@
 import { GomokuDirectionTypes, GomokuDirections } from './constant'
 import type { GomokuDirectionType } from './constant'
-import type { IGomokuContext } from './context.type'
-import type { IDirCounter, IGomokuBoard, IGomokuPiece } from './types'
+import type { IGomokuContext } from './types/context'
+import type { IDirCounter, IGomokuBoard, IGomokuPiece } from './types/misc'
 import { createHighDimensionArray } from './util/createHighDimensionArray'
 
 const { full: fullDirectionTypes, rightHalf: halfDirectionTypes } = GomokuDirectionTypes
@@ -25,7 +25,6 @@ export class GomokuContext implements IGomokuContext {
   public readonly TOTAL_POS: number
   public readonly MIDDLE_POS: number
   public readonly board: Readonly<IGomokuBoard>
-  public readonly idx: (r: number, c: number) => number
   protected readonly _idxMap: Readonly<IIdxMap>
   protected readonly _gomokuDirections: Readonly<IGomokuDirections>
   protected readonly _maxMovableMap: number[][] // [dirType][posId] => MAX_MOVABLE_STEPS
@@ -44,7 +43,6 @@ export class GomokuContext implements IGomokuContext {
     const _MAX_DISTANCE_OF_NEIGHBOR: number = Math.max(1, MAX_DISTANCE_OF_NEIGHBOR)
     const _TOTAL_PLAYER = 2
     const _TOTAL_POS: number = _MAX_ROW * _MAX_COL
-    const idx = (r: number, c: number): number => r * _MAX_ROW + c
 
     this.MAX_ROW = _MAX_ROW
     this.MAX_COL = _MAX_COL
@@ -54,12 +52,11 @@ export class GomokuContext implements IGomokuContext {
     this.TOTAL_POS = _TOTAL_POS
     this.MIDDLE_POS = _TOTAL_POS >> 1
     this.board = new Array(_TOTAL_POS).fill(-1)
-    this.idx = idx
 
     const _idxMap: IIdxMap = new Array(_TOTAL_POS)
     for (let r = 0; r < _MAX_ROW; ++r) {
       for (let c = 0; c < _MAX_COL; ++c) {
-        const posId: number = idx(r, c)
+        const posId: number = this.idx(r, c)
         _idxMap[posId] = [r, c]
       }
     }
@@ -93,7 +90,7 @@ export class GomokuContext implements IGomokuContext {
           _dirStartPosMap[revDirType][posId] = posId
           _dirStartPosSet[revDirType].push(posId)
         } else {
-          const posId2 = idx(r2, c2)
+          const posId2 = this.idx(r2, c2)
           _maxMovableMap[dirType][posId] = _maxMovableMap[dirType][posId2] + 1
           _dirStartPosMap[revDirType][posId] = _dirStartPosMap[revDirType][posId2]
         }
@@ -218,6 +215,10 @@ export class GomokuContext implements IGomokuContext {
     return true
   }
 
+  public idx(r: number, c: number): number {
+    return r * this.MAX_ROW + c
+  }
+
   public revIdx(posId: number): Readonly<[r: number, c: number]> {
     return this._idxMap[posId]
   }
@@ -256,6 +257,33 @@ export class GomokuContext implements IGomokuContext {
     return this._neighborPlacedCount[posId] > 0
   }
 
+  public couldReachFinalInDirection(
+    playerId: number,
+    posId: number,
+    dirType: GomokuDirectionType,
+  ): boolean {
+    const { MAX_ADJACENT, board } = this
+    const revDirType: GomokuDirectionType = dirType ^ 1
+
+    const maxMovableSteps0: number = this.maxMovableSteps(posId, revDirType)
+    const maxMovableSteps2: number = this.maxMovableSteps(posId, dirType)
+    if (maxMovableSteps0 + maxMovableSteps2 + 1 < MAX_ADJACENT) return false
+
+    let count = 1
+    for (let id = posId, step = 0; step < maxMovableSteps0; ++step) {
+      id = this.fastMoveOneStep(id, revDirType)
+      if (board[id] !== playerId) break
+      count += 1
+    }
+
+    for (let id = posId, step = 0; step < maxMovableSteps2; ++step) {
+      id = this.fastMoveOneStep(id, dirType)
+      if (board[id] !== playerId) break
+      count += 1
+    }
+    return count >= MAX_ADJACENT
+  }
+
   public getStartPosId(posId: number, dirType: GomokuDirectionType): number {
     return this._dirStartPosMap[dirType][posId]
   }

Diff for: packages/gomoku/src/count-map.ts

@@ -1,20 +1,20 @@
 import type { GomokuDirectionType } from './constant'
 import { GomokuDirectionTypeBitset, GomokuDirectionTypes } from './constant'
-import type { IGomokuContext } from './context.type'
-import type { IGomokuCountMap } from './count-map.type'
+import type { IGomokuContext } from './types/context'
+import type { IGomokuCountMap } from './types/count-map'
 import { createHighDimensionArray } from './util/createHighDimensionArray'
 
 const { rightHalf: halfDirectionTypes } = GomokuDirectionTypes
 const { rightHalf: allDirectionTypeBitset } = GomokuDirectionTypeBitset
 
 export class GomokuCountMap implements IGomokuCountMap {
   public readonly context: Readonly<IGomokuContext>
-  protected readonly _mustDropPosSet: Array<Set<number>> // [playerId] => <must-drop position set>
+  protected readonly _mustWinPosSet: Array<Set<number>> // [playerId] => <must-drop position set>
   protected readonly _candidateCouldReachFinal: number[][] // [playerId][posId]
 
   constructor(context: Readonly<IGomokuContext>) {
     this.context = context
-    this._mustDropPosSet = createHighDimensionArray(() => new Set<number>(), 2)
+    this._mustWinPosSet = createHighDimensionArray(() => new Set<number>(), context.TOTAL_PLAYER)
     this._candidateCouldReachFinal = createHighDimensionArray(
       () => 0,
       context.TOTAL_PLAYER,
@@ -23,28 +23,30 @@ export class GomokuCountMap implements IGomokuCountMap {
   }
 
   public init(): void {
-    this._mustDropPosSet.forEach(set => set.clear())
     this._candidateCouldReachFinal.forEach(item => item.fill(0))
+    this._mustWinPosSet.forEach(set => set.clear())
 
-    const { context, _mustDropPosSet, _candidateCouldReachFinal } = this
-    const { TOTAL_POS } = context
+    const { context } = this
+    const { TOTAL_POS, board } = context
+    const [ccrf0, ccrf1] = this._candidateCouldReachFinal
+    const [mwps0, mwps1] = this._mustWinPosSet
 
     // Initialize _candidateCouldReachFinal.
     for (let posId = 0; posId < TOTAL_POS; ++posId) {
-      if (context.board[posId] >= 0) continue
+      if (board[posId] >= 0) continue
 
       let flag0 = 0
       let flag1 = 0
       for (const dirType of halfDirectionTypes) {
         const bitFlag: number = 1 << dirType
-        if (this._couldReachFinalInDirection(0, posId, dirType)) flag0 |= bitFlag
-        if (this._couldReachFinalInDirection(1, posId, dirType)) flag1 |= bitFlag
+        if (context.couldReachFinalInDirection(0, posId, dirType)) flag0 |= bitFlag
+        if (context.couldReachFinalInDirection(1, posId, dirType)) flag1 |= bitFlag
       }
 
-      if (flag0 > 0) _mustDropPosSet[0].add(posId)
-      if (flag1 > 0) _mustDropPosSet[1].add(posId)
-      _candidateCouldReachFinal[0][posId] = flag0
-      _candidateCouldReachFinal[1][posId] = flag1
+      ccrf0[posId] = flag0
+      ccrf1[posId] = flag1
+      if (flag0 > 0) mwps0.add(posId)
+      if (flag1 > 0) mwps1.add(posId)
     }
   }
 
@@ -58,8 +60,8 @@ export class GomokuCountMap implements IGomokuCountMap {
     this._updateRelatedCouldReachFinal(posId)
   }
 
-  public mustDropPos(playerId: number): Iterable<number> & { size: number } {
-    return this._mustDropPosSet[playerId]
+  public mustWinPosSet(playerId: number): Iterable<number> & { size: number } {
+    return this._mustWinPosSet[playerId]
   }
 
   public candidateCouldReachFinal(playerId: number, posId: number): boolean {
@@ -96,14 +98,14 @@ export class GomokuCountMap implements IGomokuCountMap {
 
   protected _updateCouldReachFinal(posId: number, expiredBitset: number): void {
     if (expiredBitset > 0) {
-      const { _mustDropPosSet, _candidateCouldReachFinal } = this
+      const { context, _mustWinPosSet, _candidateCouldReachFinal } = this
       const prevFlag0 = _candidateCouldReachFinal[0][posId]
       const prevFlag1 = _candidateCouldReachFinal[1][posId]
 
-      _mustDropPosSet[0].delete(posId)
-      _mustDropPosSet[1].delete(posId)
+      _mustWinPosSet[0].delete(posId)
+      _mustWinPosSet[1].delete(posId)
 
-      if (this.context.board[posId] >= 0) {
+      if (context.board[posId] >= 0) {
         _candidateCouldReachFinal[0][posId] = 0
         _candidateCouldReachFinal[1][posId] = 0
         return
@@ -114,8 +116,8 @@ export class GomokuCountMap implements IGomokuCountMap {
       for (const dirType of halfDirectionTypes) {
         const bitFlag: number = 1 << dirType
         if (bitFlag & expiredBitset) {
-          if (this._couldReachFinalInDirection(0, posId, dirType)) nextFlag0 |= bitFlag
-          if (this._couldReachFinalInDirection(1, posId, dirType)) nextFlag1 |= bitFlag
+          if (context.couldReachFinalInDirection(0, posId, dirType)) nextFlag0 |= bitFlag
+          if (context.couldReachFinalInDirection(1, posId, dirType)) nextFlag1 |= bitFlag
         } else {
           nextFlag0 |= prevFlag0 & bitFlag
           nextFlag1 |= prevFlag1 & bitFlag
@@ -124,34 +126,8 @@ export class GomokuCountMap implements IGomokuCountMap {
 
       _candidateCouldReachFinal[0][posId] = nextFlag0
       _candidateCouldReachFinal[1][posId] = nextFlag1
-      if (nextFlag0 > 0) _mustDropPosSet[0].add(posId)
-      if (nextFlag1 > 0) _mustDropPosSet[1].add(posId)
-    }
-  }
-
-  protected _couldReachFinalInDirection(
-    playerId: number,
-    posId: number,
-    dirType: GomokuDirectionType,
-  ): boolean {
-    const { context } = this
-    const { MAX_ADJACENT, board } = context
-    const revDirType: GomokuDirectionType = dirType ^ 1
-
-    let count = 1
-    const maxMovableSteps0: number = context.maxMovableSteps(posId, revDirType)
-    for (let id = posId, step = 0; step < maxMovableSteps0; ++step) {
-      id = context.fastMoveOneStep(id, revDirType)
-      if (board[id] !== playerId) break
-      count += 1
-    }
-
-    const maxMovableSteps2: number = context.maxMovableSteps(posId, dirType)
-    for (let id = posId, step = 0; step < maxMovableSteps2; ++step) {
-      id = context.fastMoveOneStep(id, dirType)
-      if (board[id] !== playerId) break
-      count += 1
+      if (nextFlag0 > 0) _mustWinPosSet[0].add(posId)
+      if (nextFlag1 > 0) _mustWinPosSet[1].add(posId)
     }
-    return count >= MAX_ADJACENT
   }
 }

Diff for: packages/gomoku/src/index.ts

@@ -1,17 +1,23 @@
 export * from './constant'
 export * from './context'
-export * from './context.type'
 export * from './count-map'
-export * from './count-map.type'
+export * from './searcher-context'
 export * from './solution'
 export * from './state'
-export * from './state.type'
-export * from './state-cache'
-export * from './state-compressor'
-export * from './search/alpha-beta'
-export * from './search/deep'
-export * from './search/narrow'
+
+export * from './searcher/alpha-beta'
+export * from './searcher/deep'
+export * from './searcher/narrow'
+
+export * from './types/context'
+export * from './types/count-map'
+export * from './types/misc'
+export * from './types/searcher'
+export * from './types/searcher-context'
+export * from './types/state'
+
 export * from './util/createHighDimensionArray'
+export * from './util/createMinimaxSearcher'
 export * from './util/createScoreMap'
-export * from './util/createMinimaxSearcherContext'
-export * from './types'
+export * from './util/state-cache'
+export * from './util/state-compressor'