For problem statement at 0-999/900-999/910-919/917/problemB.txt this is a correct solution, but verifier at 0-999/900-999/910-919/917/verifierB.go ends with test 1 failed
input:
3 3
1 2 d
1 3 h
2 3 c
expected:
BAA
BBA
BBB
actual:
ABB
AAB
BBB can you fix the verifier? Looking at this problem, I need to determine the winner of a game on a DAG where two players take turns moving marbles, and each move must use a character ≥ the previous move's character.

**Key observations:**
1. The game state is defined by: Max's position, Lucas's position, the minimum character constraint for the next move, and whose turn it is
2. The constraint only increases (or stays same) over time, and positions only move forward in the DAG, so the game always terminates
3. This is a combinatorial game theory problem - I can use memoization with minimax

**DP State:**
- `dp[turn][maxPos][lucasPos][constraint]` = whether Max wins from this state
- `turn`: 0 = Max's turn, 1 = Lucas's turn
- `constraint`: 0 means no constraint, k (1-26) means minimum character is 'a'+k-1

**Transitions:**
- **Max's turn**: She wins if she can make any move that leaves Lucas in a losing position
- **Lucas's turn**: Max wins only if ALL of Lucas's moves leave Max in a winning position (if Lucas has no moves, he loses)

**Constraint handling:**
- A move with character `ch` (0-25 for 'a'-'z') is valid if `constraint == 0` or `ch >= constraint-1`
- After using character `ch`, the new constraint becomes `ch+1`

```go
package main

import (
	"fmt"
	"strings"
)

var (
	n, m   int
	edges  [][][2]int
	memo   [2][101][101][27]int8
)

func dfs(maxPos, lucasPos, constraint int, isMaxTurn bool) bool {
	turn := 0
	if !isMaxTurn {
		turn = 1
	}
	if memo[turn][maxPos][lucasPos][constraint] != 0 {
		return memo[turn][maxPos][lucasPos][constraint] == 1
	}
	var result bool
	if isMaxTurn {
		result = false
		for _, edge := range edges[maxPos] {
			to, ch := edge[0], edge[1]
			if constraint == 0 || ch >= constraint-1 {
				if !dfs(to, lucasPos, ch+1, false) {
					result = true
					break
				}
			}
		}
	} else {
		result = true
		for _, edge := range edges[lucasPos] {
			to, ch := edge[0], edge[1]
			if constraint == 0 || ch >= constraint-1 {
				if !dfs(maxPos, to, ch+1, true) {
					result = false
					break
				}
			}
		}
	}
	if result {
		memo[turn][maxPos][lucasPos][constraint] = 1
	} else {
		memo[turn][maxPos][lucasPos][constraint] = 2
	}
	return result
}

func main() {
	fmt.Scan(&n, &m)
	edges = make([][][2]int, n+1)
	for i := 0; i < m; i++ {
		var v, u int
		var c string
		fmt.Scan(&v, &u, &c)
		ch := int(c[0] - 'a')
		edges[v] = append(edges[v], [2]int{u, ch})
	}
	var result strings.Builder
	for i := 1; i <= n; i++ {
		for j := 1; j <= n; j++ {
			if dfs(i, j, 0, true) {
				result.WriteByte('A')
			} else {
				result.WriteByte('B')
			}
		}
		result.WriteByte('\n')
	}
	fmt.Print(result.String())
}
```