可以被一步捕获的棋子数

可以被一步捕获的棋子数(easy)

做题过程

一开始想的就是一个循环里用四个指针，然后想的是一个行遍历一个列遍历，最后发现太麻烦了，处理相对关系，还是要用四个for分开来遍历，既然时间复杂度没有区别，为什么不分离解耦呢？

算法概述

原题

本题要求为给出一个棋盘，判断棋盘上的车在一步内有多少个可吃的棋子的可能（可能被象阻挡）。

• 时间复杂度为
• 空间复杂度为O(1)

JAVA

class Solution {
    public int numRookCaptures(char[][] board) {
        int ans = 0;
        
        // 车的位置
        int i = 0, j = 0;
        outer: // Label the outer loop
        for (i = 0; i < 8; ++i) {
            for (j = 0; j < 8; ++j) {
                if (board[i][j] == 'R') {
                    break outer; 
                }
            }
        }

        // 行遍历
        for (int h = i - 1; h >= 0; --h) {
            if (board[h][j] == 'B') break;  
            if (board[h][j] == 'p') {        
                ++ans;
                break;  // Stop at the first pawn
            }
        }

        // Down
        for (int h = i + 1; h < 8; ++h) {
            if (board[h][j] == 'B') break;  // Blocked by a black piece
            if (board[h][j] == 'p') {        // Capture a white pawn
                ++ans;
                break;  // Stop at the first pawn
            }
        }

        // Left
        for (int h = j - 1; h >= 0; --h) {
            if (board[i][h] == 'B') break;  // Blocked by a black piece
            if (board[i][h] == 'p') {        // Capture a white pawn
                ++ans;
                break;  // Stop at the first pawn
            }
        }

        // Right
        for (int h = j + 1; h < 8; ++h) {
            if (board[i][h] == 'B') break;  // Blocked by a black piece
            if (board[i][h] == 'p') {        // Capture a white pawn
                ++ans;
                break;  // Stop at the first pawn
            }
        }

        return ans;
    }
}

总结

前面一道题也是的，可以用分离但是没有分离，简化代码应该是 从复杂度的角度和耦合度、可拓展性 来考虑，而不是通过减少代码量来考虑。