每日两题 / 240. 搜索二维矩阵 II && 48. 旋转图像 - 力扣（LeetCode热题100）

240. 搜索二维矩阵 II - 力扣（LeetCode）

从右上角开始搜索，若当前值大于target，向左走，因为当前列的所有值都大于target
若当前值小于target，则当前行向左的所有值小于target，向下走

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size() - 1, n = matrix[0].size() - 1;
        int x = 0, y = n;
        while (x >= 0 && x <= m && y >= 0 && y <= n)
        {
            if (target == matrix[x][y]) return true;
            else if (target < matrix[x][y]) y -- ;
            else x ++ ;
        }
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

48. 旋转图像 - 力扣（LeetCode）

讲一个符合我直觉的解法：从外向内，一层层地旋转
每次完成一层中4个数的位置交换，如何得到这4个数的坐标？
每次坐标的变化，方向都是固定的：右下左上
并且每次的曼哈顿距离都是相同的
加上每次向一个方向移动k个曼哈顿距离，但是移动后的坐标“出界”，此时就要向另一个方向调整
将出界的曼哈顿距离加到另一个方向上

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size(), m = matrix[0].size();
        int dx[4] = { 0, 1, 0, -1 }, dy[4] = { 1, 0, -1, 0 };
        int l = 0, r = m - 1, u = 0, d = n - 1;
        int len = m - 1;
        for (int i = 0; i < n / 2; ++ i)
        {
            for (int j = i; j < m - i - 1; ++ j)
            {
                int x = i, y = j;
                int next, cur = matrix[x][y];
                for (int k = 0; k < 4; ++ k)
                {
                    int nx = x + len * dx[k], ny = y + len * dy[k];
                    if (ny > r)
                    {
                        nx += (ny - r);
                        ny = r;
                    }
                    else if (nx > d)
                    {
                        ny -= (nx - d);
                        nx = d;
                    }
                    else if (ny < l)
                    {
                        nx -= (l - ny);
                        ny = l;
                    }
                    else if (nx < u)
                    {
                        ny += (u - nx);
                        nx = u;
                    }
                    x = nx, y = ny;
                    next = matrix[nx][ny];
                    matrix[nx][ny] = cur;
                    cur = next;
                }

            }
            l ++ , r --, u ++ , d -- ;
            len -= 2;
        }
    }
};

// 右下左上
// j+, i+
// i+, j-
// j-, i+
// i-, j+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54