螺旋矩阵解法

已于 2023-02-28 15:55:28 修改
阅读量124 收藏
点赞数
分类专栏： 算法 文章标签： 算法 矩阵
于 2023-02-27 14:42:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45334752/article/details/129241439
版权

螺旋矩阵1 力扣54题

在这插入图片描述
没有复杂的数据结构，按照流程复现处理好边界问题即可。
第一种解法:设置边界，不断更新边界条件。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector <int> ans;
        if(matrix.empty()) return ans; //若数组为空，直接返回答案
        int u = 0; //赋值上下左右边界
        int d = matrix.size() - 1;
        int l = 0;
        int r = matrix[0].size() - 1;
        while(true){
            for(int i=l;i<=r;++i) ans.push_back(matrix[u][i]);
            if(++u>d) break;
            for(int i=u;i<=d;++i) ans.push_back(matrix[i][r]);
            if(--r<l) break;
            for(int i=r;i>=l;--i) ans.push_back(matrix[d][i]);
            if(--d<u) break;
            for(int i=d;i>=u;--i) ans.push_back(matrix[i][l]);
            if(++l>r) break;
        }
        return ans;
    }
}；

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if not matrix:
            return []
        ans = []
        left,top=0,0
        right=len(matrix[0])
        bottom=len(matrix)
        while(True):
            for i in range(top,right):
                ans.append(matrix[top][i])
            top += 1 #重新定义上边界
            if(top>=bottom):
                break
            
            for j in range(top,bottom):
                ans.append(matrix[j][right-1])
            right = right - 1 #重新定义右边界
            if(right<=left):
                break
            
            for m in range(right-1,left-1,-1):
                ans.append(matrix[bottom-1][m])
            bottom = bottom - 1 #重新定义下边界
            if(bottom<=top):
                break

            for n in range(bottom-1,top-1,-1):
                ans.append(matrix[n][left])
            left = left + 1 #重新定义左边界
            if(left>=right):
                break
            
        
        return ans

第二种解法不预先设置边界，需要一个数组记录元素是否被访问 dx dy为方向矩阵 移动的四个方向 从左到右 上到下 右到左 下到上

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector <int> ans;
        int m = matrix.size();
        int n = matrix[0].size();
        if(matrix.empty()) return ans; //若数组为空，直接返回答案
        vector<vector<bool>> st(m,vector<bool>(n,false));
        int x = 0,y=0,d=0;
        int dx[] = {0,1,0,-1},dy[]={1,0,-1,0};
        for(int i=0;i<m*n;i++){
            ans.push_back(matrix[x][y]);
            int a = x + dx[d];
            int b = y + dy[d];
            st[x][y] = true;
            if(a<0||a>=m||b<0||b>=n||st[a][b]){
                d = (d+1) % 4;
            }
            x += dx[d];
            y += dy[d];
        }
        return ans;
    }
};

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if not matrix:
            return []
        ans = []
        m = len(matrix)
        n = len(matrix[0])
        import numpy as np
        # st = [[0 for i in range(m+2)] for j in range(n+2)]
        st = np.zeros((m,n),dtype=int)
        x=0
        y=0
        d=0
        dx = [0,1,0,-1]
        dy = [1,0,-1,0]
        for i in range(m*n):
            ans.append(matrix[x][y])
            st[x][y]=1
            a=x+dx[d]
            b=y+dy[d]
            if(a<0 or a>=m or b<0 or b>=n or st[a][b]):
                d = (d+1)%4      
            x +=dx[d]
            y += dy[d]
        return ans

螺旋矩阵2 力扣59

在这里插入图片描述

题解：1的逆过程，解法与1相同。第一种提前设置好边界

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> matrix(n, vector<int>(n));
    int top=0;
    int left = 0;
    int right = n-1;
    int bottom = n-1;
    int a = 1;
    while (true) {
        for (int i = left; i <= right; i++) {
            matrix[top][i] = a;
            a += 1;
        }
        if (++top > bottom) break;

        for (int i = top; i <= bottom; i++) {
            matrix[i][right] = a;
            a += 1;
        }
        if (--right < left) break;

        for (int i = right; i >= left; i--) {
            matrix[bottom][i] = a;
            a += 1;
        }
        if (--bottom < top) break;

        for (int i = bottom; i >= top; i--) {
            matrix[i][left] = a;
            a += 1;
        }
        if (++left > right) break;
        
    }

    return matrix;
}
};

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        matrix = [ [0 for i in range(n)] for j in range(n)]
        top=left=0
        bottom=right=n-1
        a = 1
        while(True):
            for i in range(top,right+1):
                matrix[top][i] = a
                a +=1
            top +=1
            if(top>bottom): 
                break
            
            for i in range(top,bottom+1):
                matrix[i][right] = a
                a += 1
            right -= 1
            if(right<left): 
                break
            
            for i in range(right,left-1,-1):
                matrix[bottom][i] = a
                a += 1
            bottom -= 1
            if(bottom<top):
                break
            
            for i in range(bottom,top-1,-1):
                matrix[i][left] = a
                a += 1
            
            left += 1
            if(left>right):
                break
        return matrix

第二种

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> matrix(n, vector<int>(n,0));
    int x=0,y=0,d=0;
    int dx[] = {0,1,0,-1};
    int dy[] = {1,0,-1,0};
    for(int i=1;i<=n*n;i++){
        matrix[x][y] = i;
        int a = x + dx[d];
        int b = y + dy[d];
        if(a<0||a>=n||b>=n||b<0||matrix[a][b]!=0){
            d = (d+1) %4;
        }
        x += dx[d];
        y += dy[d];
    }
    return matrix;
}
};

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        matrix = [ [0 for i in range(n)] for j in range(n)]
        x=0
        y=0
        d=0
        dx = [0,1,0,-1]
        dy = [1,0,-1,0]
        len = (n * n) + 1
        for i in range(1,len):
            matrix[x][y]=i
            a = x + dx[d]
            b = y + dy[d]
            if((a<0) or (a>=n) or (b<0) or (b>=n) or (matrix[a][b]!=0)):
                d = (d+1) % 4
            x += dx[d]
            y += dy[d]
        return matrix

螺旋矩阵3 力扣885

在这里插入图片描述
题解：与前面一样设置变换矩阵dx dy 通过观察可以发现 步长为1 1 2 2 3 3 4 4 .。不用考虑边界问题

class Solution {
public:
    vector<vector<int>> spiralMatrixIII(int rows, int cols, int rStart, int cStart) {
        vector<vector<int>> matrix;
        int maxa = rows>cols?rows:cols;
        int x= rStart;
        int y=cStart;
        int sum = rows* cols;
        int dx[] = {0,1,0,-1};
        int dy[] = {1,0,-1,0};
        int d = 0;
        int count =1;
            while(sum){
            int len = count;
            for(int a =0;a<2;a++){
                for(int c=1;c<=count;c++){
                if(x>=0 && x<rows && y>=0 && y<cols){
                     matrix.push_back({x,y});
                     sum--;
                }
                x += dx[d];
                y += dy[d];
              }
            d = (d+1) % 4;
            }
         
            count++;
        }
        return matrix;
    }
    
};

螺旋矩阵4 力扣2326

在这里插入图片描述
和1，2，解法一样。初始化数组全为-1即可；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
        vector<vector<int>> matrix(m,vector<int>(n,-1)); //返回的矩阵
        int x=0;
        int y=0;
        int d=0; //定义当前xy位置d表示运动方向
        int dx[]={0,1,0,-1};
        int dy[]={1,0,-1,0}; //定义运动方向数组
    
        while(head!=nullptr){
            matrix[x][y] = head->val;
    
            int a= x+dx[d];
            int b = y+dy[d];
            if(a<0||a>=m||b<0||b>=n ||matrix[a][b]!=-1){
                d = (d+1)%4;
            }
            x += dx[d];
            y += dy[d];
            head=head->next;
            

        }
        return matrix;
        
    }
};

//第二种方法在需要在每次移动之前判断当前指针是否为空指针。
class Solution {
public:
    vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
        vector<vector<int>> matrix(m,vector<int>(n,-1)); //返回的矩阵
        int top=0;
        int left=0;
        int right=n-1;
        int bottom=m-1;
        while(head!=nullptr){
           for(int i=left;i<=right;i++){
               if(head==nullptr) break;
                matrix[top][i]=head->val;
                head=head->next;
            }
            if(++top>bottom || head==nullptr) break;

            for(int i=top;i<=bottom;i++){
                if(head==nullptr) break;
                matrix[i][right]=head->val;
                head=head->next;
            }
            if(--right<left || head==nullptr) break;

            for(int i=right;i>=left;i--){
                if(head==nullptr) break;
                matrix[bottom][i]=head->val;
                head=head->next;
            }
            if(--bottom<top || head==nullptr) break;

             for(int i=bottom;i>=top;i--){
                if(head==nullptr) break;
                matrix[i][left]=head->val;
                head=head->next;
            }
            if(++left>right || head==nullptr) break;
        }
    
        return matrix;
    }
    
};

python 版本代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        matrix = [[-1 for i in range(n)] for j in range(m)]
        x=0
        y=0
        d=0
        dx = [0,1,0,-1]
        dy = [1,0,-1,0]
        while(head):
            matrix[x][y]=head.val
            head = head.next
            a = x + dx[d]
            b = y + dy[d]
            if(a<0 or a>=m or b<0 or b>=n or matrix[a][b]!=-1):
                d = (d+1)%4
            
            x += dx[d]
            y += dy[d]
        return matrix

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        matrix = [[-1 for i in range(n)] for j in range(m)]
        top=0
        left=0
        right=n
        bottom=m

        while(True):
            for i in range(left,right):
                if(head is not None):
                    matrix[top][i] = head.val
                    head = head.next
            top +=1
            if(top>=bottom or head is None):
                break

            for i in range(top,bottom):
                if(head is not None):
                    matrix[i][right-1] = head.val
                    head = head.next
            right -=1
            if(left>=right or head is None):
                break

            for i in range(right-1,left-1,-1):
                if(head is not None):
                    matrix[bottom-1][i] = head.val
                    head = head.next
            bottom -=1
            if(top>=bottom or head is None):
                break

            
            for i in range(bottom-1,top-1,-1):
                if(head is not None):
                    matrix[i][left] = head.val
                    head = head.next
            left +=1
            if(left>=right or head is None):
                break;


        return matrix
要努力啊xlx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
螺旋矩阵 题解
su1495120的博客
01-23 4343
螺旋矩阵   【问题描述】 一个n行n列的螺旋矩阵可由如下方法生成： 从矩阵的左上角（第1行第1列）出发，初始时向右移动； 如果前方是未曾经过的格子， 则继续前进，否则右转； 重复上述操作直至经过矩阵中所有格子。根据经过顺序，在格子中依次填入1, 2, 3, ... , n2，便构成了一个螺旋矩阵。 下图是一个n = 4 时的螺旋矩阵。  现给出矩阵大小n以及i和j，
矩阵螺旋排序
DFrY的博客
10-06 317
#include "qttesteveryday.h" #include <QtWidgets/QApplication> #include <QVector> #include <stdio.h> #include <vector> #include <string> #include <iostream> #include <sstream> #include <algorithm> using namesp
浅谈用矩阵求斐波那契数列
weixin_64821987的博客
03-18 861
导语 两个矩阵的乘法仅当第一个矩阵AAA 的列数和第二个矩阵BBB 的行数相等时才能定义。如 AAA 是m∗nm*nm∗n矩阵，BBB是n∗pn*pn∗p的矩阵，他们的乘积 CCC=(ci,j)(c_{i,j})(ci,j​),它的任意一个元素值为： ci,j=ai,1b1,j+ai,2b2,j+...+ai,nbn,j=∑n=1nai,rbr,jc_{i,j}=a_{i,1}b_{1,j}+a_{i,2}b_{2,j}+...+a_{i,n}b_{n,j}= \sum\limits_{n=1}^na_{i
螺旋矩阵-数字矩阵
aliven1的博客
05-08 470
然后做一下思考，一个边长为n的正方形矩阵，每次转完外圈，螺旋向内收缩时，边长收缩为n1=n-2；挡转完这个圈，再向内时，边长再度收缩为n2=n1-2；也就是n这个数包含几个2，就需要转几圈。也就是和n/2有关。当n为奇数，需要转的完整圈数也是n/2，但是最后肯定回缩圈到一个3x3的矩阵，最后一个数字放在最中央。但是严格来说应该是(n/2)+1圈，最后一圈缩到一个1x1的矩阵。当n为偶数，这个圈数就是n/2；画一下边长为2～5的情况。n就是题目给出的正整数。
【现代机器人学——螺旋理论】UR5机器人正运动学求解
qq_23297513的博客
01-23 5232
系列文章目录 系列目录暂无 提示：本文介绍基于螺旋理论分析的UR5机器人正逆运动学求解思路，仅供参考。 文章目录系列文章目录前言一、辅助公式二、正运动学1.定义工作末端2.定义运动轴3.定义螺旋变换矩阵4.基于螺旋理论的UR5机器人正向运动学公式三、逆运动学1.准备工作8.关于RK子问题总结 前言 螺旋理论 参考文章： 《UR机械臂正逆运动学求解》与此文章理论方法、坐标系以及参数定义不太相同，可将xy方向数据取反验证。 一、辅助公式 二、正运动学 1.定义工作末端 首先我们针对旋量理论支撑的运动模型
一看就懂的螺旋矩阵
热门推荐
Google大神
11-27 1万+
今天为大家分享一道关于螺旋矩阵的问题。话不多说，直接看题目吧。 01、题目分析 第54题：螺旋矩阵 定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。 示例 1: 输入: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 输出: [1,2,3,6,9,8,7,4,5] 示例 2: 输入: [ [1, 2, 3, 4], [5, 6, 7, 8], [9,10,11,12] ] 输.
螺旋矩阵
ywk253100的专栏
03-23 2200
73   74   75   76   77   78   79   80  81    72   43   44   45   46   47   48   49   50    71   42   21   22   23   24   25   26   51    70   41   20    7     8      9   10   27   52    69   40
c++-c++编程基础之leetcode题解第54螺旋矩阵.zip
04-09
在本压缩包中，主题聚焦于C++编程基础与LeetCode题目的结合，特别是针对第54题“螺旋矩阵”（Spiral Matrix）的解法。LeetCode是一个在线平台，提供了一系列编程挑战，旨在帮助程序员提升算法技能和解决实际问题的...
螺旋矩阵 noip2014普及组1.doc
11-19
### 螺旋矩阵问题分析与解法 #### 一、题目背景与要求 螺旋矩阵问题是NOIP2014普及组的一个经典编程题目。题目要求在给定一个正方形矩阵大小`n`以及矩阵中的某一点`(i, j)`的情况下，求出该点上的数字。这里所说的...
python-leetcode面试题解之第54题螺旋矩阵-题解.zip
03-19
标题中的“python-leetcode面试题解之第54题螺旋矩阵-题解.zip”表明这是一个关于Python编程语言的LeetCode面试题解答，具体是针对第54题——螺旋矩阵（Spiral Matrix）的解题代码和分析。LeetCode是一个在线平台，...
python-leetcode面试题解之第59题螺旋矩阵II-题解.zip
03-19
在本压缩包中，我们关注的是Python编程与LeetCode面试题解的相关内容，特别是关于第59题“螺旋矩阵II”的解法。LeetCode是一个在线平台，提供了许多编程题目，帮助程序员提升技能并准备技术面试。以下是针对这个面试...
华为OD机试 - 螺旋数字矩阵（Java 、 JS 、 Python 、 C 、 C++）
06-07
多种语言解法，粉丝可免费领取题库体验卡，请私信获取，私信获取体验卡 2024版华为OD机试题库，包含C、D卷所有真题，粉丝可领取体验卡免费看题，包含面试手撕代码等等内容
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 924
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 221
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 233
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 295
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 529
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 615
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 279
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
python最小二乘法的矩阵解法
09-08
Python中的最小二乘法可以使用矩阵解法来实现。最小二乘法是一种用于拟合数据的统计方法，通过求解最小化误差平方和的目标函数来得到回归方程。以下是使用矩阵解法实现最小二乘法的步骤： 1. 导入必要的库：首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值