算法学习——引导（二维指针）

最新推荐文章于 2024-11-12 12:29:51 发布

PikaPikac_

最新推荐文章于 2024-11-12 12:29:51 发布

阅读量65

点赞数

分类专栏：算法学习文章标签：算法学习

本文链接：https://blog.csdn.net/ifuturer/article/details/133561950

版权

算法学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

第一题反转图像

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {
        // //空间复杂度O(n) 时间复杂度O(n2)
        // auto ret = image;
        // int n = image.size();
        // int m = image[0].size();
        
        // for(int i = 0; i < n; i++)
        // {
        //     for(int j = 0; j < m; j++)
        //     {
        //         ret[i][j] = 1 - image[i][m - j - 1];
        //     }
        // }
        // return ret;

        //空间复杂度O(1) 时间复杂度O(n2) 双指针  1^1 = 0，0^1=1
        int n = image.size();

        for(int i = 0; i < n; i++)
        {
            int left = 0;
            int right = n - 1;
            while(left < right)
            {
                //如果需要置换的元素不同，则置换取反后结果与未操作一致，所以仅需对需置换的相同元素取反即可
                if(image[i][left] == image[i][right])
                {
                    image[i][left] ^= 1;
                    image[i][right] ^= 1;
                }
                left++;
                right--;
            }
            //如果是列数是奇数，上述while循环在left == right时退出，对中间元素取反
            if(left == right)
            {
                image[i][right] ^= 1;
            }
        }
        return image;
    }
};

第二题转置矩阵

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        //空间复杂度O(n)， 时间复杂度O(n2)
        int n = matrix.size();
        int m = matrix[0].size();
        vector<vector<int>> ret(m, vector<int>(n));
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                ret[i][j] = matrix[j][i];
            }
        }
        return ret;
    }
};

第三题重塑矩阵

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int m = mat.size();
        int n = mat[0].size();

        if(r * c != m * n)
        {
            return mat;
            cout << "error.";
        }

        vector<vector<int>> ret = vector(r, vector<int>(c));
        //时间复杂度O（n2）
        // int id;
        // for(int i = 0; i < r; i++)
        // {
        //     for(int j = 0; j < c; j++)
        //     {
        //         id = i * c + j; 
        //         ret[i][j] = mat[id / n][id % n];
        //     }
        // }

        //时间复杂度O（n）
        for(int x = 0; x < m * n; x++)
        {
            ret[x / c][x % c] = mat[x / n][x % n];
        }
        return ret;
    }
};

第四题将一维数组转变成二维数组

在这里插入图片描述

第五题二维网格迁移

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> shiftGrid(vector<vector<int>>& grid, int k) {
        auto ret = grid;
        int m = grid.size();
        int n = grid[0].size();
        int nums = n * m;
        for(int i = 0; i < nums; i++)
        {
           ret[((i + k) % nums) / n][((i + k) % nums) % n] = grid[i / n][i % n];
        }
        return ret;
    }
};

第六题图片平滑器

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> imageSmoother(vector<vector<int>>& img) {
        int m = img.size();
        int n = img[0].size();
        auto ret = img;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                int sum = 0;
                int num = 0;
                for(int x = i - 1; x <= i + 1; x++)
                {
                    for(int y = j - 1; y <= j + 1; y++)
                    {
                        if(x >= 0 && x < m && y >= 0 && y < n)
                        {
                            num++;
                            sum += img[x][y];
                        }
                    }
                }
                ret[i][j] = sum / num;
            }
        }
        return ret;
    }
};