算法学习——引导（二维数组）

最新推荐文章于 2024-07-28 19:07:21 发布

PikaPikac_

最新推荐文章于 2024-07-28 19:07:21 发布

阅读量38

点赞数

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

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

版权

算法学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章描述了关于矩阵操作的一系列编程题目，涉及计数负数、对角线元素求和、客户资产最大值、判断托普利茨矩阵、幸运数检查、特殊位置计算以及岛屿周长的求解，主要使用了暴力法和深度优先搜索等算法。

摘要由CSDN通过智能技术生成

第一题统计有序矩阵中的负数

在这里插入图片描述

class Solution {
public:
    int countNegatives(vector<vector<int>>& grid) {
        //暴力
        // int ans = 0;
        // for(int i = 0; i < grid.size(); i++)
        // {
        //     for(int j = 0; j < grid[0].size(); j++)
        //     {
        //         if(grid[i][j] < 0)
        //         {
        //             ans++;
        //         }
        //     }
        // }
        // return ans;
        
        //二分
        // int ans = 0;
        // for (int i = 0; i < grid.size(); i++)
        // {
        //     int left = 0;
        //     int right = grid[0].size() - 1;
        //     int k = grid[i].size();
        //     while (left <= right)
        //     {

        //         int mid = (left + right) / 2;
        //         if(grid[i][mid] >= 0)
        //         {
        //             left = mid + 1;
        //         }
        //         else
        //         {
        //             k = mid;
        //             right = mid - 1;
        //         }
        //     }
        //     ans += grid[i].size() - k;
        // }
        // return ans;
    }
};

第二题矩阵对角线元素的和

在这里插入图片描述

class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        // int n = mat.size();
        // int sum = 0;
        // int mid = n / 2;
        // for(int i = 0; i < n; i++)
        // {
        //     sum += mat[i][i] + mat[i][n - 1 - i];//当前行中处于对角线的元素为：坐标 (i,i)和坐标 (i,n−i−1)
        // }

        // return sum - mat[mid][mid] * (n % 2);

        int n = mat.size();
        int sum = 0;
        int mid = n / 2;
        for(int i = 0; i < n; i++)
        {
            sum += mat[i][i];//当前行中处于对角线的元素为：坐标 (i,i)和坐标 (i,n−i−1)
            if(n - i - 1 != i)//奇数行，去掉一个重复元素
            {
                sum += mat[i][n - i - 1];
            }
        }

        return sum;
    }
};

第三题最富有客户的资产量

在这里插入图片描述

class Solution {
public:
    int maximumWealth(vector<vector<int>>& accounts) {
    //     //暴力
    //     int max = 0;
    //     for(int i = 0; i < accounts.size(); i++)
    //     {
    //         int tmp = 0;
    //         for(int j = 0; j < accounts[i].size(); j++)
    //         {
    //             tmp += accounts[i][j];
    //         }
    //         if(tmp > max)
    //         {
    //             max = tmp;
    //         }
    //     }
    //     return max;
    
    // 库函数调用
    int ret = 0;
    for(auto & account : accounts)
    {
        ret = max(ret, accumulate(account.begin(), account.end(), 0));
    }
    return ret;


    }
};

第四题托普利茨矩阵

在这里插入图片描述

class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        // //暴力
        int m = matrix.size();
        int n = matrix[0].size();
        int l = 0;
        int v = 0;
        for(int i = 1; i < m; i++)
        {
            for(int j = 1; j < n; j++)
            {
                if(matrix[i][j] != matrix[i - 1][j - 1])
                    return false;
            }
        }
        return true;

    }
};

第五题矩阵中的幸运数

在这里插入图片描述

class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        // //暴力
        int m = matrix.size();
        int n = matrix[0].size();
        int l = 0;
        int v = 0;
        for(int i = 1; i < m; i++)
        {
            for(int j = 1; j < n; j++)
            {
                if(matrix[i][j] != matrix[i - 1][j - 1])
                    return false;
            }
        }
        return true;

    }
};

第六题二进制矩阵中的特殊位置

在这里插入图片描述

class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int m = mat.size();
        int n = mat[0].size();
        vector<int> row_ans(m, 0);
        vector<int> col_ans(n, 0);
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(mat[i][j] == 1)
                {
                    row_ans[i]++;
                    col_ans[j]++;
                }
            }
        }

        int ret = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(mat[i][j] == 1 && row_ans[i] == 1 && col_ans[j] == 1)
                {
                    ret++;
                }
            }
        }
        return ret;
    }
};

第七题岛屿的周长

在这里插入图片描述

class Solution {
    constexpr static int dx[4] = {0, 1, 0, -1};
    constexpr static int dy[4] = {1, 0, -1, 0};

    int dfs(int x, int y, vector<vector<int>>& grid, int m, int n )
    {
        if(x < 0 || y < 0 || x >= m || y >= n || grid[x][y] == 0)
            return 1;
        
        if(grid[x][y] == 2)
            return 0;
        
        grid[x][y] = 2;
        
        int res = 0;
        for(int k = 0; k < 4; k++)
        {
            int tx = x + dx[k];
            int ty = y + dy[k];
            res += dfs(tx, ty, grid, m, n);
        }
        return res;

    }


public:
    int islandPerimeter(vector<vector<int>>& grid) {
        //四个方向迭代
        // int m = grid.size();
        // int n = grid[0].size();
        // int ans = 0;
        // for(int i = 0; i < m; i++)
        // {
        //     for(int j = 0; j < n; j++)
        //     {
        //        if(grid[i][j])
        //        {
        //            int cnt = 0;
        //            for(int k = 0; k < 4; k++)
        //            {
        //                int tx = i + dx[k];
        //                int ty = j + dy[k];
        //                if(tx < 0 || ty < 0 || tx >= m || ty >= n || !grid[tx][ty])
        //                {
        //                    cnt++;
        //                }
        //            }
        //            ans += cnt;
        //        }
               
        //     }
        // }
        // return ans;


        // 深度优先搜索
        int m = grid.size();
        int n = grid[0].size();
        int ans = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == 1)
                {
                    ans += dfs(i, j, grid, m, n);
                }
                
            }
        }
        return ans;
    }
};