【LeetCode: 1222. 可以攻击国王的皇后:dfs | bfs】

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，CSDN-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚩 题目链接

• 1222. 可以攻击国王的皇后

⛲ 题目描述

在一个 8x8 的棋盘上，放置着若干「黑皇后」和一个「白国王」。

给定一个由整数坐标组成的数组 queens ，表示黑皇后的位置；以及一对坐标 king ，表示白国王的位置，返回所有可以攻击国王的皇后的坐标(任意顺序)。

🌟 求解思路&实现代码&运行结果

---

⚡ dfs | bfs

🥦 求解思路

1. 思路1：从国王的角度开始，判断8个方向上是否存在皇后，如果存在 ，直接收集坐标，结束这个方向的判断，再判断其他方向即可。
2. 思路2：从皇后的角度开始，从每一个皇后的位置开始，去判断它8个方向上是否可以看到国王，如果可以，先收集答案。但是需要注意的是，我们只需要该方向上最靠近国王的位置坐标。
3. 有了基本的思路，接下来我们就来通过思路1，具体的代码来实现一下。

🥦 实现代码1 - - - > dfs

class Solution {

    List<List<Integer>> res;
    List<Integer> list;
    int[][] queens;
    int n=8;
    
    public List<List<Integer>> queensAttacktheKing(int[][] queen, int[] king) {
        res=new ArrayList<List<Integer>>();
        this.queens=new int[n][n];
        for(int[] v:queen){
            queens[v[0]][v[1]]=1;
        }
        int x=king[0],y=king[1];
        dfs(x,y,-1,0);
        dfs(x,y,1,0);
        dfs(x,y,0,1);
        dfs(x,y,0,-1);
        dfs(x,y,-1,-1);
        dfs(x,y,-1,1);
        dfs(x,y,1,1);
        dfs(x,y,1,-1);
        return res;
    }

    public void dfs(int x,int y,int i,int j){
        if(x<0||x>=n||y<0||y>=n) return;
        if(queens[x][y]==1){
            list=new ArrayList<>();
            list.add(x);
            list.add(y);
            res.add(list);
            return;
        }
        dfs(x+i,y+j,i,j);        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

🥦 运行结果1

时间复杂度&空间复杂度

🥦 实现代码2 - - - > bfs

class Solution {
    int[][] dir={{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
    public List<List<Integer>> queensAttacktheKing(int[][] queens, int[] king) {
        boolean[][] flag=new boolean[8][8];
        for (int[] q:queens) {
            flag[q[0]][q[1]]=true;
        }
        List<List<Integer>> ans=new ArrayList<>();
        for (int[] d:dir) {
            int x = king[0] + d[0];
            int y = king[1] + d[1];
            while (0<=x&&x<8&&0<=y&&y<8){
                if (flag[x][y]){
                    ans.add(List.of(x, y));
                    break;
                }
                x+=d[0];
                y+=d[1];
            }
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

🥦 运行结果2

时间复杂度&空间复杂度

---

💬 共勉