leetcode-999

这题看懂题意没难度，但是有没有更好的非步进迭代思路呢，比如一个棋盘巨大的那种，按方向迭代就显得有些低效了。看了提交的代码没发现比较好的思路，首先是不是能在找白棋的步骤简化一些，这里的问题是必须要xy同时满足才能确定白棋坐标，那我想能否用大范围的rand思路配合多指针，毕竟如果是一亿行列的棋盘，这种时间复杂度肯定会爆掉。找到白棋后再直接开多个协程去吃棋子。

原始版本

package main

func numRookCaptures(board [][]byte) int {
    dx := []int{-1, 1, 0, 0}
    dy := []int{0, 0, -1, 1}

    for i := 0; i < 8; i++ {
        for j := 0; j < 8; j++ {
            if board[i][j] == 'R' {
                res := 0
                for k := 0; k < 4; k++ {
                    x := i
                    y := j
                    for {
                        x += dx[k]
                        y += dy[k]
                        if x < 0 || x >= 8 || y >= 8 || y < 0 || board[x][y] == 'B' {
                            break
                        }
                        if board[x][y] == 'p' {
                            res++
                            break
                        }
                    }
                }
                return res
            }
        }
    }
    return 0
}

稍微加了点并发，实际上，优化问题的关键在于如何找白棋坐标，我也没想到比较可行的方法，难道分批次再开goroutine？

package main

import "sync"
var wg sync.WaitGroup

func numRookCaptures(board [][]byte) int {

    dx := []int{-1, 1, 0, 0}
    dy := []int{0, 0, -1, 1}

    for i := 0; i < 8; i++ {
        for j := 0; j < 8; j++ {
            if board[i][j] == 'R' {
                res := 0
                wg.Add(4)
                for k := 0; k < 4; k++ {
                    go eat(board, dx, dy, i, j, k, &res)
                }

                wg.Wait()
                return res
            }
        }
    }
    wg.Wait()
    return 0
}

func eat(board [][]byte, dx []int, dy []int, x, y, k int, res *int) {

    for {
        x += dx[k]
        y += dy[k]
        if x < 0 || x >= 8 || y >= 8 || y < 0 || board[x][y] == 'B' {
            wg.Done()
            break
        }
        if board[x][y] == 'p' {
            *res++
            wg.Done()
            break
        }
    }
}

end