华为OD机考算法题：评论转换输出

题目部分

题目	评论转换输出
难度	难
题目说明	在一个博客网站上，每篇博客都有评论。每一条评论都是一个非空英文字母字符串。评论具有树状结构，除了根评论外，每个评论都有一个父评论。当评论保存时，使用以下格式： 首先是评论的内容； 然后是回复当前评论的数量； 最后是当前评论的所有子评论。(子评论使用相同的格式嵌套存储) 所有元素之间都用单个逗号分隔。 例如，如果评论如下： 第一条评论是 "hello,2,ok,0,bye,0"，第二条评论是 "test,0"，第三条评论是 "one,1,two,1,a,0"。 所有评论被保存成 "hello,2,ok,0,bye,0,test,0,one,1,two,1,a,0"。   对于上述格式的评论，请以另外一种格式打印： 首先打印评论嵌套的最大深度。 然后是打印n行，第 i (1 ≤ i ≤ n)行对应于嵌套级别为 i 的评论(根评论的嵌套级别为 1 )。 对于第i行，嵌套级别为的评论按照它们出现的顺序打印，用空格分隔开。
输入描述	一行评论。由英文字母、数字和英文逗号组成。 保证每个评论都是由英文字符组成的非空字符串。 每个评论的数量都是整数(至少由一个数字组成)。 整个字符串的长度不超过。 给定的评论结构保证是合法的。
输出描述	按照给定的格式打印评论。对于每一级嵌套，评论应该按照输入中的顺序打印。
补充说明	无
------------------------------------------------------
示例
示例1
输入	hello,2,ok,0,bye,0,test,0,one,1,two,1,a,0
输出	3 hello test one ok bye two a
说明	如题目描述中图所示，最大的嵌套级别为 3。嵌套级别为 1 的评论是 “hello test one”，嵌套级别为 2 的评论是“ok bye two”，嵌套级别为 3 的评论是 “a”。
示例2
输入	A,5,A,0,a,0,A,0,a,0,A,0
输出	2 A A a A a A
说明	如下图所示，最大嵌套级别为 2， 嵌套级别为 1 的评论是 “A”，嵌套级别为 2 的评论是 “A a A a A”。
示例3
输入	A,3,B,2,C,0,D,1,E,0,F,1,G,0,H,1,1,1,J,0,K,1,L,0,M,2,N,0,0,1,P,0
输出	4 A K M B F H L N O C D G I P E J
说明	如下图所示。

解读与分析

题目解读：

输入一段字符串，根据给定的规则把它转换成另外的格式输出。

分析与思路：

此题可以使用递归的思路实现。时间复杂度和空间复杂度均为 O(n)。

代码实现

Java代码

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
/**
 * 评论转换输出
 * 
 * @since 2023.10.18
 * @version 0.1
 * @author Frank
 *
 */
public class CommentsTransfer {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			String input = sc.nextLine();
			String[] inputStr = input.split(",");
			int count = inputStr.length / 2;
			String[] contents = new String[count];
			int[] childrenCnt = new int[count];
			for (int i = 0; i < count; i++) {
				contents[i] = inputStr[2 * i];
				childrenCnt[i] = Integer.parseInt(inputStr[2 * i + 1]);
			}
			processCommentsTransfer(contents, childrenCnt);
		}
	}
 
	private static void processCommentsTransfer(String[] contents, int[] childrenCnt) {
		List> commentsList = new ArrayList>();
		int curLevel = 0;
		int curIndex = 0;
		while (curIndex <= contents.length - 1) {
			curIndex = processEachLevel(curIndex, curLevel, commentsList, contents, childrenCnt);
		}
		System.out.println( commentsList.size() );
		for( int i = 0; i < commentsList.size(); i ++ )
		{
			List comments = commentsList.get( i );
			for( int j = 0; j < comments.size(); j ++ )
			{
				System.out.print( comments.get( j ));
				if( j < comments.size() - 1 )
				{
					System.out.print( "," );
				}else
				{
					System.out.println();
				}
			}
		}
	}
 
	private static int processEachLevel(int curIndex, int curLevel, List> commentsList, String[] contents,
			int[] childrenValues) {
		int index = curIndex;
		
		List comments;
		if( curLevel >= commentsList.size() )
		{
			comments = new ArrayList();
			commentsList.add( comments );
		}else
		{
			comments = commentsList.get( curLevel );
		}
		
		int curChildrenCnt = childrenValues[ curIndex ];
		
		comments.add( contents[index] );
		index ++;
		
		if( curChildrenCnt == 0 )
		{
			return index;
		}
		// 有children的情况
		for( int i = 0; i < curChildrenCnt; i ++ )
		{			
			index = processEachLevel( index, curLevel + 1, commentsList, contents, childrenValues);
		}
		return index;
	}
}

JavaScript代码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void async function() {
    while (line = await readline()) {
        var inputArr = line.split(",");
        var count = inputArr.length / 2;
        var contents = new Array();
        for (var i = 0; i < count; i++) {
            var eachContent = new Array();
            eachContent[0] = inputArr[2 * i];
            eachContent[1] = parseInt(inputArr[2 * i + 1]);
            contents[i] = eachContent;
        }
        processCommentsTransfer(contents);
    }
}();
 
function processCommentsTransfer(contents) {
    var commentsList = new Array();
    var curLevel = 0;
    var curIndex = 0;
    while (curIndex <= contents.length - 1) {
        curIndex = processEachLevel(curIndex, curLevel, commentsList, contents);
    }
 
    console.log(commentsList.length);
    for (var i = 0; i < commentsList.length; i++) {
        var outputStr = "";
        var comments = commentsList[i];
        for (var j = 0; j < comments.length; j++) {
            outputStr += comments[j];
            if (j < comments.length - 1) {
                outputStr += ",";
            }
        }
        console.log(outputStr);
    }
}
 
function processEachLevel(curIndex, curLevel, commentsList, contents) {
    var index = curIndex;
 
    var comments;
    if (curLevel >= commentsList.length) {
        comments = new Array();
        commentsList.push(comments);
    } else {
        comments = commentsList[curLevel];
    }
 
    var curChildrenCnt = contents[index][1];
 
    comments.push(contents[index][0]);
    index++;
 
    if (curChildrenCnt == 0) {
        return index;
    }
    // 有children的情况
    for (var i = 0; i < curChildrenCnt; i++) {
        index = processEachLevel(index, curLevel + 1, commentsList, contents);
    }
    return index;
}

(完)