Match alphanumerical pattern in matrix i

impl Solution {
  pub fn find_pattern(board: Vec<Vec<i32>>, pattern: Vec<String>) -> Vec<i32> {
    let rows = board.len();
    let cols = board[0].len();
    let pr = pattern.len();
    let pc = pattern[0].len();
    let pattern: Vec<Vec<u8>> = pattern.iter().map(|s| s.bytes().collect()).collect();
    
    for r in 0..=rows - pr {
      for c in 0..=cols - pc {
        if Self::matches(&board, &pattern, r, c) {
          return vec![r as i32, c as i32];
        }
      }
    }
    vec![-1, -1]
  }
  
  fn matches(board: &[Vec<i32>], pattern: &[Vec<u8>], r: usize, c: usize) -> bool {
    let mut letter_to_digit = [255u8; 26]; // letter -> digit mapping
    let mut digit_to_letter = [255u8; 10]; // digit -> letter mapping (for bijectivity)
    
    for dr in 0..pattern.len() {
      for dc in 0..pattern[0].len() {
        let ch = pattern[dr][dc];
        let board_val = board[r + dr][c + dc] as u8;
        
        if ch.is_ascii_digit() {
          // Must match exactly
          if board_val != ch - b'0' {
            return false;
          }
        } else {
          // Letter
          let idx = (ch - b'a') as usize;
          if letter_to_digit[idx] == 255 {
            // Not yet mapped
            if digit_to_letter[board_val as usize] != 255 && digit_to_letter[board_val as usize] != ch {
              return false; // This digit is already mapped to a different letter
            }
            letter_to_digit[idx] = board_val;
            digit_to_letter[board_val as usize] = ch;
          } else if letter_to_digit[idx] != board_val {
            return false; // Inconsistent mapping
          }
        }
      }
    }
    true
  }
}