0006 - Z字形变换2022-04-20

将一个给定字符串 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

/*
 * @lc app=leetcode.cn id=6 lang=java
 *
 * [6] Z 字形变换
 *
 * https://leetcode-cn.com/problems/zigzag-conversion/description/
 *
 * algorithms
 * Medium (51.92%)
 * Likes:    1653
 * Dislikes: 0
 * Total Accepted:    421.4K
 * Total Submissions: 811.5K
 * Testcase Example:  '"PAYPALISHIRING"\n3'
 *
 * 将一个给定字符串 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 由英文字母（小写和大写）、',' 和 '.' 组成
 * 1 
 * 
 * 
 */

方法一：利用二维矩阵模拟

java 判断字符非空: ch != 0。

class Solution {
    /**
     * @param s 给定字符串
     * @param numRows 给定行数
     * @return
     * 
     * Z 字形变换:
     * 设 n 为字符串 s 的长度，r=numRows。
     * 对于 r=1（只有一行）或者 r≥n（只有一列）的情况，答案与 s 相同，我们可以直接返回 s。
     * 对于其余情况，
     * 考虑创建一个二维矩阵，然后在矩阵上按 Z 字形填写字符串 s，最后逐行扫描矩阵中的非空字符，
     * 组成答案。
     * 
     * 根据题意，当我们在矩阵上填写字符时，会向下填写 r 个字符，然后向右上填写 r - 2 个字符，
     * 最后回到第一行，因此Z字形变换的周期 t = r + r - 2 = 2r - 2,
     * 每个周期会占用矩阵上的 1 + r - 2  = r - 1 列，
     * 因此我们有 n/t个周期，(最后一个视作完整的周期),乘上每个周期的列数，
     * 得到的矩阵的列数 c = n/t * (r-1).
     * 
     * 创建一个 r 行 c 列的矩阵，然后遍历字符串 s 并按照 Z 字形填写。
     * 具体来说，设当前填写的位置为 (x,y),即 x行 y列，初始 (x,y)=(0,0),即矩阵左上角。
     * 若当前字符下标 i 满足 i mod t < r - 1(每个周期的前r-1个字符),则向下移动，否则向右上移动。
     */

    public String convert(String s, int numRows) {
        int n = s.length();
        int r = numRows;
        if(n <= r || r == 1){
            return s;
        }

        int t = 2*r - 2 ;// t = r + r-2 = 2r-2
        int c = (n + t - 1 )/t * (r-1); // 周期数乘以一个周期的列数为总列数，(n+ t-1):中加上(t-1)的目的是为了保证原字符串中最后不足一个完整周期的字符串视作一个完整周期，而不是整除后减少一个周期
        // 创建 Z 字形矩阵
        char[][] mat = new char[r][c];
        for(int i = 0,x=0,y=0; i < n; ++ i){
            mat[x][y] = s.charAt(i);
            if(i % t < r - 1){
                ++x; // 向下移动
            }else{
                --x; // 向右上移动
                ++y;
            }
        }
        StringBuffer ans = new StringBuffer();
        for(char[] row: mat){
            for(char ch: row){
                if(ch!=0){
                    ans.append(ch);
                }
            }
        }
        return ans.toString();
    }
}

方法二：压缩矩阵空间

方法一种的矩阵有大量的空间没有被使用，可以优化。

注意到每次往矩阵的某一行添加字符时，都会添加到该行上一个字符的右侧，且最后组成答案时只会用到每行的非空字符。因此我们可以将矩阵的每行初始化为一个空列表，每次向某一行添加字段时，添加到该行的列表末尾即可。

class Solution{

    public String convert(String s, int numRows) {
        int n = s.length(), r = numRows;
        if(r >= n || r == 1){
            return s;
        }
        // 创建一个 r的空列表，每行用于存放Z字形变换后的每行的字符
        StringBuffer[] mat = new StringBuffer[r];
        for(int i = 0;i<r;i++){
            mat[i] = new StringBuffer();
        }
        int t = 2*r - 2;
        for(int i = 0,x=0,y=0; i < n;i++){
            mat[x].append(s.charAt(i)); // 将字符添加到行尾
            if(i % t < r - 1){
                ++x; // 下一行
            }else{
                --x; // 上一行
            }
        }
        StringBuffer ans = new StringBuffer();
        for(StringBuffer row:mat){
            ans.append(row);
        }
        return ans.toString(); 
    }

}

方法三：直接构造 

这个方法需要深度思考。

这个需要考虑到进行 Z 字形转换后字符是放到一个矩阵内的，矩阵的行数是r行，矩阵的列数由矩字符的长度n和行数r共同决定，一个周期内的字符数为 t = r + r -2 = 2r-2，列数为（ n +  t - 1)/r，这里是 加了一个周期减去1个字符的长度，这样在除以(整除)行数的时候得到的周期数就不会因为最后一个周期不足一个完整的周期，而使得周期数减少1了(说白了就是不足一个周期当做一个周期)，一个周期内在同一行的字符数量：一个周期内在矩阵的第一行以及在第 r 行只有一个字符，一个周期内在矩阵其余行为两个字符。

代码如下：

class Solution {
public:
    string convert(string s, int numRows) {
        int n = s.length(),r = numRows;
        if(r==1 || n <= r){
            return s;
        }
        string ans;
        int t = 2*r - 2; // r + r - 2
        for(int i=0; i < r; i++){ // 枚举矩阵的行，按行填写，每行的多个周期值一次填写
            for(int j = 0; j+i < n;j+=t){ // j += t 类似周期函数的思想，可以保证遍历到多个周期，j + i < n 保证跳到下一个i
                ans += s[j+i];// 当前周期内在第i行的第1个字符
                // Z 字形矩阵 一个周期内 中间的行是存在两个字符的(同一个行，不同的列)
                if(i > 0 && i < r - 1 && j+t-i < n){ // j+t-i < n是防止最后一个周期时同一行没有第二个字符
                    ans += s[j+t-i];
                }
            }
        }
        return ans;
    }
};