[剑指Offer]---11 旋转数组的最小数字与12 矩阵中的路径

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

思路

旋转数组其实是由两个有序数组拼接而成的，因此我们可以使用二分法

(1)array[mid] > array[high]:

出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。
low = mid + 1

(2)array[mid] == array[high]:

出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，\此时最小数字不好判断在mid左边还是右边,这时只好一个一个试 。
high = high - 1

(3)array[mid] < array[high]:

出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左
边。因为右边必然都是递增的。
high = mid

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int low=0,high=numbers.size()-1;
      
        while (low<high)
        {
            int mid=(high+low)/2;

            if(numbers[mid]>numbers[high]){
                low=mid+1;
            }
            else if (numbers[mid]==numbers[high])
            {
                high-=1;
            }
            else{
                high=mid;
            }

        }
        
        return numbers[low];
    }
};

 

12 矩阵中的路径

题目

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

 

示例 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

提示：

    1 <= board.length <= 200
    1 <= board[i].length <= 200。

思路

利用回溯法求解

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


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


    bool search(vector<vector<char>>& board, int i,int j,string word,int idx){
        if(idx==word.size()){
            return true;
        }

        if (i < 0 || i >= board.size()    || 
            j < 0 || j >= board[0].size() ||
            board[i][j] != word[idx]){
                return false;
            }
           
        board[i][j] = '*';
        bool res = search(board, i - 1, j, word, idx + 1) ||
                   search(board, i + 1, j, word, idx + 1) ||
                   search(board, i, j - 1, word, idx + 1) ||
                   search(board, i, j + 1, word, idx + 1);
        board[i][j]= word[idx];
        return res;
    }
};