LeetCode05

面试题11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [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

解：采用二分查找的思想，先找出中间元素middle。 再判别middle是在左侧有序数组还是右侧。

代码如下：

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int left = 0;
        int right = numbers.size() - 1;
        while (left < right) {
            int mid = (left + right) >>1;
            if (numbers[mid] > numbers[right]) {
                // 说明mid在左侧有序数组，排除mid以及mid左边的元素
                left = mid + 1;
            } else if (numbers[mid] < numbers[right]) {
                // 说明mid在右侧有序数组，排除mid右边的元素
                right = mid;
            } else {
                // 去重
                right--;
            }
        }
        return numbers[left];   
    }
};

面试题12. 矩阵中的路径 

 解：该题类型属于DFS，重要的是要找到 DFS 的起点和终点，以及继续 DFS 搜索的方向（规则）。

参考讨论中写的代码如下：

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
     if (board.empty() || board.size() == 0 || board[0].size() == 0) {
        return false;
    }

    for (int i = 0; i < board.size(); i++) {
        for (int j = 0; j < board[0].size(); j++) {
            if(board[i][j]==word[0]){
                if (dfs(board, word, 0, i, j)) {
                    return true;
                }
            }
        }
    }

    return false;
}

private:
bool dfs(std::vector<std::vector<char>> &board, const std::string &word, int index, int x, int y) {
    //判断是否越界和是否继续递归
    if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size() || board[x][y] != word[index]) {
        return false;
    }

    //递归结束
    if (index == word.size() - 1) {
        return true;
    }

    //直接改变矩阵中的值，防止重复搜索
    //比使用mark[][]数组存储访问标志要简单
    char tmp = board[x][y];
    board[x][y] = '.';

    //递归查找，查询的四个方向：上下左右{(x+1,y),(x-1,y),(x,y+1),(x,y-1)}
    if (dfs(board, word, index + 1, x, y + 1)
        || dfs(board, word, index + 1, x, y - 1)
        || dfs(board, word, index + 1, x + 1, y)
        || dfs(board, word, index + 1, x - 1, y)) {
        return true;
    }
    //恢复为原值
    board[x][y] = tmp;

    return false;   
    }
};