深度优先算法和二分法剩余部分

矩阵中的路径

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
例如，在下面的 3×4 的矩阵中包含单词 “ABCCED”（单词中的字母已标出）。

示例 1：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：
输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

解题思路

第一步先遍历一遍board，寻找第一个符合的位置，然后再使用dfs递归，因为寻找路径，要记录一下路径，防止每次递归会回到之前的路径。

var exist = function(board, word) {
    let row = board.length;
    let col = board[0].length;
    const dfs = function(board,word,i,j,index){
        if(i<0 || i>=row || j<0 || j>=col || board[i][j] != word[index]) return false;
        if(index == word.length-1) return true;
        var tmp = board[i][j];
        board[i][j] = '-';
        let res = dfs(board,word,i+1,j,index+1) || dfs(board,word,i,j+1,index+1) || dfs(board,word,i-1,j,index+1) || dfs(board,word,i,j-1,index+1);
        board[i][j] = tmp
        return res
    }
    for(let i=0;i<row;i++){
        for(let j=0;j<col;j++){
            if(dfs(board,word,i,j,0)) return true
        }
    }
    return false
};

旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：
输入：[3,4,5,1,2]
输出：1
示例 2：
输入：[2,2,2,0,1]
输出：0

解题思路1

二分法
首先，创建两个指针 left, right 分别指向 numbers 首尾数字，然后计算出两指针之间的中间索引值 middle，然后我们会遇到以下三种情况：
middle > right ：代表最小值一定在 middle 右侧，所以 left 移到middle+1 的位置。
middle < right ：代表最小值一定在 middle 左侧或者就是 middle，所以 right移到 middle 的位置。
middle既不大于 left 指针的值，也不小于 right 指针的值，代表着 middle 可能等于 left指针的值，或者 right 指针的值，我们这时候只能让 right 指针递减，来一个一个找最小值了。

var minArray = function(numbers) {
    let low = 0;
    let high = numbers.length-1;
    while(low<high){
        let mid = Math.floor((low + high)/2);
        if(numbers[mid]<numbers[high]){
            high = mid;
        }else if(numbers[mid]>numbers[high]){
            low = mid + 1;
        }else{
            high -= 1;
        }
    }
    return numbers[low]
};

解题思路2

利用内置min函数

var minArray = function(numbers) {
    return Math.min(...numbers)
};