【LeetCode N 字形变换】

6. N 字形变换

难度中等

题目描述

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：

P   A   H   N
A P L S I I G
Y   I   R

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

示例 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

示例 3：

输入：s = "A", numRows = 1
输出："A"

提示：

• 1 <= s.length <= 1000
• s 由英文字母（小写和大写）、',' 和 '.' 组成
• 1 <= numRows <= 1000

解题思路

作者一开始想到的思路是将原字符串以N字形排列存入一个二维字符数组中，然后再从头遍历此数组来获取变换后的字符串。

P			I			N
A		L	S		I	G
Y	A		H	R
P			I

此方法优点直观，容易想到，但是难点在于确定二维数组的列数，作者在这里推到出一个求解列数的公式：

• 如果字符串长度（len）%（2倍的行数（numRows）-2）!=0

                那么所需列数为：       numLines = ( len / ( 2*numRows - 2 ) +1 ) * ( numRows - 1 )

• 如果字符串长度（len）%（2倍的行数（numRows）-2）==0

                那么所需列数为：       numLines = ( len / ( 2*numRows - 2 ) ) * ( numRows - 1 )

然后创建出所需空间的二维数组即可

// 创建一个大小为3x4的二维字符向量
vector<vector<char>> arr(numRows, vector<char>(numLines, '0'));

之后再将字符串按一定顺序填入二维数组即可，最后遍历的时候从第一行开始，遇到'0' 跳过，最后便可的到变换后的字符串。

注意：当numRows（行数）为1的时候，直接return 原字符串即可！（因为一行无法构成N形）

接下来是本题另一种思路：

这个思路主要是找到N字形字符串的规律来按照一定的规律将字符串变换后输出。

可以 发现在每一个N字形中可以形成一个规律区间：

 

首先我们将第一行的字符依次输出（相隔距离公式为2*numRows-2）

int len = s.length();                   // 获取字符串长度
int len1 = 2 * numRows - 2;              // 计算Z字形图案中每个完整的循环的长度
string str;                             // 定义一个字符串变量 str，用于存储转换后的字符串
for (int i = 0; i < len; i += len1) {    // 遍历字符串 s，并将每个完整的循环的第一行字符添加到 str 中
    str += s[i];
}

 这时候可以发现从第二行开始往下，可以将N字形分为若干个规律区间，每个区间中为对称排列，根据下图可以发现：

 

 

 区间首尾元素对称，对比上面二维图便可以发现第二行中的A与L对称，S与I对称。

来到第三行，区间对称收缩，此时变为Y与A对称，H与R对称，

 

 到最后一行的时候只剩下最中间的一个元素，所以直接输出即可。

注意：同理，当numRows（行数）为一行的时候，依旧直接返回原字符串即可！

int w = len1 - 1;                        // 初始化 w 为每个 N 字形图案的区间宽度 
int st = 1;                              // 初始化 st 为每个 N 字形图案段的区间开始 
while (w > 0) {                          // 当还有 Z 字形图案段落需要转换时
    for (int i = st; i < len; i += len1) {   // 遍历字符串 s，将每个 N 字形图案段落中的字符添加到 str 中
        str += s[i];                            // 添加当前行的字符
        if (i + w - 1 > len - 1) break;      // 如果当前行的下一个字符不存在，则跳出循环
        if (w != 1) str += s[i + w - 1];      // 如果不是最后一行，则添加反向斜线上的字符
    }
    w-=2;                                     // 减小每个 N 字形图案段落的宽度
    st++;                                       // 增加每个 N 字形图案段落的起始点
}

最后附上本人完整通过代码：

#include<iostream>
#include<string>
using namespace std;

class Solution {
public:
    string convert(string s, int numRows) {  
        if (numRows == 1) return s;				// 如果输入的行数为1，则返回原字符串
        int len = s.length();                   // 获取字符串长度
        int len1 = 2 * numRows - 2;              // 计算Z字形图案中每个完整的循环的长度
        string str;                             // 定义一个字符串变量 str，用于存储转换后的字符串
        for (int i = 0; i < len; i += len1) {    // 遍历字符串 s，并将每个完整的循环的第一行字符添加到 str 中
            str += s[i];
        }
        int w = len1 - 1;                        // 初始化 w 为每个 N 字形图案的区间宽度 
        int st = 1;                              // 初始化 st 为每个 N 字形图案段的区间开始 
        while (w > 0) {                          // 当还有 Z 字形图案段落需要转换时
            for (int i = st; i < len; i += len1) {   // 遍历字符串 s，将每个 N 字形图案段落中的字符添加到 str 中
                str += s[i];                            // 添加当前行的字符
                if (i + w - 1 > len - 1) break;      // 如果当前行的下一个字符不存在，则跳出循环
                if (w != 1) str += s[i + w - 1];      // 如果不是最后一行，则添加反向斜线上的字符
            }
            w-=2;                                     // 减小每个 N 字形图案段落的宽度
            st++;                                       // 增加每个 N 字形图案段落的起始点
        }
        return str;                                 // 返回转换后的字符串
    }
};

int main() {
    Solution sol;                               // 创建一个Solution类的实例
    int numRows;                                // 定义一个整型变量 numRows，用于存储用户输入的行数
    string s;                                   // 定义一个字符串变量 s，用于存储用户输入的字符串
    cin>>s;                                  
    cin>>numRows;                           
    s=sol.convert(s, numRows);            
    cout<<s;                                  
    return 0;                                   // 完美结束
}

时间复杂度O（N），空间复杂度O（1）