1. 题目
将一个给定字符串 s
根据给定的行数
n
u
m
R
o
w
s
numRows
numRows,以从上往下、从左到右进行 Z 字形排列(倒放的Z)。
比如输入字符串为 “PAYPALISHIRING” 行数为 3 时,排列如下:
P A H N A P L S I I G Y I R P\quad\quad \,\,\,\,A\quad \quad \,\,\,\,H\quad\quad N\\ A\quad P\quad L\quad S\quad I\quad I\quad G\\ Y\quad \quad \,\,\,\,I\quad \quad \,\,\,\,R PAHNAPLSIIGYIR
之后,你的输出需要从左往右逐行读取,产生出一个新的字符串,比如:“PAHNAPLSIIGYIR”。
请你实现这个将字符串进行指定行数变换的函数:
convert(s: str, numRows: int) -> str
示例 1:
输入:s = “PAYPALISHIRING”, numRows = 3
输出:“PAHNAPLSIIGYIR”
示例 2:
输入:s = “PAYPALISHIRING”, numRows = 4
输出:“PINALSIGYAHRPI”
解释:
P
I
N
A
L
S
I
G
Y
A
H
R
P
I
P\quad\quad\quad\,\,\,\,\, I \quad\quad\quad\,\, N\\ A\quad \quad L\quad S \quad \quad I \quad G\\ Y\quad A\quad \,\,\,\,H \quad R\\ P\quad\quad\quad\,\,\, I
PINALSIGYAHRPI
示例 3:
输入:s = “A”, numRows = 1
输出:“A”
提示:
- 1 < = s . l e n g t h < = 1000 1 <= s.length <= 1000 1<=s.length<=1000
s
由英文字母(小写和大写)、‘,’ 和 ‘.’ 组成- 1 < = n u m R o w s < = 1000 1 <= numRows <= 1000 1<=numRows<=1000
2. 思路及代码实现(Python)
来源:力扣官方题解
2.1 利用二维矩阵模拟
设
n
n
n 为字符串 s
的长度,
r
=
n
u
m
R
o
w
s
r=numRows
r=numRows。对于
r
=
1
r=1
r=1(只有一行)或者
r
≥
n
r≥n
r≥n(只有一列)的情况,答案与 s
相同,我们可以直接返回 s
。对于其余情况,考虑创建一个二维矩阵,然后在矩阵上按 Z 字形填写字符串 s
,最后逐行扫描矩阵中的非空字符,组成答案。
根据题意,当我们在矩阵上填写字符时,会向下填写 r r r 个字符,然后向右上继续填写 r − 2 r−2 r−2 个字符,最后回到第一行,因此 Z 字形变换的周期 t = r + r − 2 = 2 r − 2 t=r+r−2=2r−2 t=r+r−2=2r−2,每个周期会占用矩阵上的 1 + r − 2 = r − 1 1+r−2=r−1 1+r−2=r−1 列。因此我们有 ⌈ n t ⌉ \Big\lceil\dfrac{n}{t}\Big\rceil ⌈tn⌉ 个周期(最后一个周期视作完整周期),乘上每个周期的列数,得到矩阵的列数 c = ⌈ n t ⌉ ⋅ ( r − 1 ) c=\Big\lceil\dfrac{n}{t}\Big\rceil\cdot(r-1) c=⌈tn⌉⋅(r−1)。创建一个 r r r 行 c c c 列的矩阵,然后遍历字符串 s s s 并按 Z 字形填写。具体来说,设当前填写的位置为 ( x , y ) (x,y) (x,y),即矩阵的 x x x 行 y y y 列。初始 ( x , y ) = ( 0 , 0 ) (x,y)=(0,0) (x,y)=(0,0),即矩阵左上角。若当前字符下标 i i i 满足 i m o d t < r − 1 i\bmod t<r−1 imodt<r−1,则向下移动,否则向右上移动。填写完成后,逐行扫描矩阵中的非空字符,组成答案。
该方法中,时间复杂度和空间复杂度都损耗在创建和遍历矩阵上,时间复杂度为 O ( r × n ) O(r\times n) O(r×n),空间复杂度为 O ( r × n ) O(r\times n) O(r×n)。
class Solution:
def convert(self, s: str, numRows: int) -> str:
n, r = len(s), numRows
if r == 1 or r >= n:
return s
t = r * 2 - 2
c = (n + t - 1) // t * (r - 1)
mat = [[''] * c for _ in range(r)]
x, y = 0, 0
for i, ch in enumerate(s):
mat[x][y] = ch
if i % t < r - 1:
x += 1 # 向下移动
else:
x -= 1
y += 1 # 向右上移动
return ''.join(ch for row in mat for ch in row if ch)
执行用时:244 ms
消耗内存:23.80 MB
2.2 压缩矩阵空间
上述方法中,容易发现,当 n u m R o w s numRows numRows 越大,在 Z 型字符串之外的无用空间就越多,这些空间不仅会增加搜索的时间,还会占用存储空间。注意到,我们按照Z型填补了字符之后,最后还是横向地将字符进行组合,因此可以将矩阵地每行初始化为一个空列表,每次根据当前的索引位置,向某一行的列表末尾添加字符即可。
经过压缩后的算法时间复杂度和空间复杂度均为 O ( n ) O(n) O(n)。
class Solution:
def convert(self, s: str, numRows: int) -> str:
r = numRows
if r == 1 or r >= len(s):
return s
mat = [[] for _ in range(r)]
t, x = r * 2 - 2, 0
for i, ch in enumerate(s):
mat[x].append(ch)
x += 1 if i % t < r - 1 else -1
return "".join("".join(l) for l in mat)
执行用时:60 ms
消耗内存:17.14 MB
2.3 直接构造
在方法一中矩阵的每个非空字符会对应到 s s s 的哪个下标(记作 $textit{idx}$),从而直接构造出答案。由于 Z 字形变换的周期为 t = 2 r − 2 t=2r−2 t=2r−2,因此对于矩阵第一行的非空字符,其对应的 idx \textit{idx} idx 均为 t t t 的倍数,即 idx ≡ 0 ( m o d t ) \textit{idx}\equiv 0\pmod t idx≡0(modt);同理,对于矩阵最后一行的非空字符,应满足 idx ≡ r − 1 ( m o d t ) \textit{idx}\equiv r-1\pmod t idx≡r−1(modt)。对于矩阵的其余行(行号设为 i i i),每个周期内有两个字符,第一个字符满足 idx ≡ i ( m o d t ) \textit{idx}\equiv i\pmod t idx≡i(modt),第二个字符满足 idx ≡ t − i ( m o d t ) \textit{idx}\equiv t-i\pmod t idx≡t−i(modt)。
本算法中每个字符仅会被访问一次,时间复杂度为 O ( n ) O(n) O(n),空间复杂度为 O ( 1 ) O(1) O(1)。
class Solution:
def convert(self, s: str, numRows: int) -> str:
n, r = len(s), numRows
if r == 1 or r >= n:
return s
t = r * 2 - 2
ans = []
for i in range(r): # 枚举矩阵的行
for j in range(0, n - i, t): # 枚举每个周期的起始下标
ans.append(s[j + i]) # 当前周期的第一个字符
if 0 < i < r - 1 and j + t - i < n:
ans.append(s[j + t - i]) # 当前周期的第二个字符
return ''.join(ans)
执行用时:60 ms
消耗内存:16.86 MB