先贴抄来的做法，完美的利用了矩阵的性质，将左下角设置为起始节点，往上的元素比自己小，往左的元素比自己大，从右上开始也是一样的想法，贴代码

 1 class Solution {
 2 public:
 3     bool searchMatrix(vector<vector<int>>& matrix, int target) 
 4     {
 5         int row = matrix.size()-1;
 6         int column = 0;
 7         while(row>=0 && column<matrix[0].size())
 8         {
 9             if(matrix[row][column] == target)
10             return true;
11             else if(matrix[row][column] > target)
12             {
13                 row--;
14             }
15             else
16             {
17                 column++;
18             }
19         }
20         return false;
21     }
22 };

做这道题的时候一直在想怎么根据元素之间的大小关系把方法简化，后来想到了根据当前元素与target之间的大小关系来划分成不同的部分，从而解决问题。就是递归的思路。对于得到的一个矩阵，对其中间列进行搜索，找到第一个大于target的元素，该元素往右往下这一子矩阵中所有元素都大于target，一定不存在target，而与该元素同一列的上个元素，其往右网上这一子矩阵中所有元素都小于target，除去这两个子矩阵，剩下两个子矩阵都有可能存在target。从而进行递归。

写了很久，但是超时了，很难过，必须贴上来，他也很不错的。

 1 class Solution {
 2 public:
 3     vector<vector<int>> mat;
 4     int tar;
 5     bool search(int left,int right,int up,int down)
 6     {
 7         if(left>right || up>down)
 8         return false;
 9         if(mat[up][left] > tar || mat[down][right] < tar)
10         return false;
11         int mid = (left+right)/2;
12         int row = up;
13         while(row <= down && mat[row][mid] <= tar)
14         {
15             if(mat[row][mid] == tar)
16             return true;
17             row++;
18         }
19         if(row == up)
20         return search(left,mid-1,up,down);
21         else if(row<=down && row>up)
22         return search(left,mid-1,row,down) || search(mid+1,right,up,row-1);
23         else
24         return search(mid+1,right,up,down);
25     }
26     bool searchMatrix(vector<vector<int>>& matrix, int target) 
27     {
28         mat = matrix;
29         tar = target;
30         return search(0,matrix[0].size()-1,0,matrix.size()-1);
31     }
32 };