leetcode-bfs和二分法

想进大厂的小菜猿

于 2022-05-07 15:23:49 发布

阅读量270

点赞数 1

分类专栏： leetcode打卡文章标签： leetcode 宽度优先算法

本文链接：https://blog.csdn.net/qq_49932989/article/details/124630985

版权

leetcode打卡专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文介绍了两种算法问题的解决方案。第一题涉及使用广度优先搜索（BFS）来找到从一个字符串到另一个字符串的最少转换步数，其中每个转换步骤仅允许修改一个字符。第二题则展示了如何在一个二维矩阵中通过二分查找法来搜索目标元素，首先将矩阵转为升序一维数组，然后进行查找。这两种方法都有效地解决了各自的问题。

摘要由CSDN通过智能技术生成

题目1：

思路：

由于出现了最少，比较明显是bfs/dfs，但是一般来说最少是使用bfs。使用StringBuffer拼接出只修改一个字符的sb【start跟end比较】,如果满足在给出的word里面，那么将他加入队列，不断进行调整

补充：

具体代码：

 /**
     * bfs
     * @return
     */
    public int bfs (String start,String end, String[] bank) {
        Set<String> cnt = new HashSet<>();
        //备忘录
        Set<String> visited = new HashSet<>();
        //可替换的键
        char[] keys = {'A','C','G','T'};

        for (String w : bank) {
            cnt.add(w);
        }

        if (start.equals(end)) {
            return 0;
        }

        if (!cnt.contains(end)) {
            return -1;
        }

        Queue<String> queue = new ArrayDeque<>();
        queue.offer(start);
        visited.add(start);
        int step = 1;
        while (!queue.isEmpty()) {
            int sz = queue.size();
            for (int i = 0; i < sz; i++) {
                String curr = queue.poll();
                for (int j = 0; j < 8; j++) {
                    for (int k = 0; k < 4; k++) {
                        if (keys[k] != curr.charAt(j)) {
                            StringBuffer sb = new StringBuffer(curr);
                            sb.setCharAt(j,keys[k]);
                            String next = sb.toString();
                            if (!visited.contains(next) && cnt.contains(next)) {
                                //满足条件
                                if (next.equals(end)) {
                                    return step;
                                }
                                queue.offer(next);
                                visited.add(next);
                            }
                        }
                    }
                }

            }
            step++;
        }
        return -1;
    }

题目2：

思路：

若将矩阵每一行拼接在上一行的末尾，则会得到一个升序数组，我们可以在该数组上二分找到目标元素。

代码实现时，可以二分升序数组的下标，将其映射到原矩阵的行和列上。

关键代码：int x = matrix[mid / n][mid % n];

代码：

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length, n = matrix[0].length;
        int low = 0, high = m * n - 1;
        while (low <= high) {
            int mid = (high - low) / 2 + low;
            int x = matrix[mid / n][mid % n];
            if (x < target) {
                low = mid + 1;
            } else if (x > target) {
                high = mid - 1;
            } else {
                return true;
            }
        }
        return false;
    }
}

//下面这种方法是先找到最后一个不大于目标值的元素所在的列，再在该元素所在的行里面寻找
class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int rowIndex = binarySearchFirstColumn(matrix, target);
        if (rowIndex < 0) {
            return false;
        }
        return binarySearchRow(matrix[rowIndex], target);
    }

    public int binarySearchFirstColumn(int[][] matrix, int target) {
        int low = -1, high = matrix.length - 1;
        while (low < high) {
            int mid = (high - low + 1) / 2 + low;
            if (matrix[mid][0] <= target) {
                low = mid;
            } else {
                high = mid - 1;
            }
        }
        return low;
    }

    public boolean binarySearchRow(int[] row, int target) {
        int low = 0, high = row.length - 1;
        while (low <= high) {
            int mid = (high - low) / 2 + low;
            if (row[mid] == target) {
                return true;
            } else if (row[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return false;
    }
}