leetcode刷题笔记[38. 外观数列]

leetcode刷题笔记

38. 外观数列

难度 简单 点赞 638

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

• countAndSay(1) = "1"
• countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。

前五项如下：

1.     1
2.     11
3.     21
4.     1211
5.     111221
第一项是数字 1 
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"

要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。

例如，数字字符串 "3322251" 的描述如下图：

示例 1：

输入：n = 1
输出："1"
解释：这是一个基本样例。

示例 2：

输入：n = 4
输出："1211"
解释：
countAndSay(1) = "1"
countAndSay(2) = 读 "1" = 一 个 1 = "11"
countAndSay(3) = 读 "11" = 二 个 1 = "21"
countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"

提示：

• 1 <= n <= 30

解法一： 朴素解法

这是一道模拟题。

我们可以实现一个 nextString 方法，传入一个字符串 s，返回该字符串对应的外观数列。

具体的实现，我们只需要统计字符串 s 中每一段连续出现的字符的类型和出现次数即可：

class Solution {
    public String countAndSay(int n) {
        /**
         * 你可以将其视作是由递归公式定义的数字字符串序列：
         * countAndSay(1) = "1"
         * countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
         */
        String s = "1";//传入方法的参数
        for (int i = 1; i < n; i++) {
            //调用方法
            s = nextString(s);
        }
        return s;
    }

    //写一个返回字符串的方法
    //传入字符串参数
    private String nextString(String s) {
        //一个可变的字符序列。用于统计与拼接字符串
        StringBuilder sb = new StringBuilder();
        //获取字符串长度
        int n = s.length();
        //将字符串转换为字符数组
        char[] cs = s.toCharArray();
        //标记第一个字符
        char c = cs[0];
        //定义计数器,已经统计一个字符cs[0]
        int count = 1;
        //开始模拟统计,下标从1开始，因为cs[0]已经用 char c=cs[0];标记从cs[1]开始与cs[0]比较是否相同
        for (int i = 1; i < n; i++) {
            //标记当前字符
            char cur = cs[i];
            //相等
            if (c == cur) {
                count++;
            } else {//不相等
                //拼接描述符 数量加字符
                sb.append(count);
                sb.append(c);
                //更新数量以及当前字符统计下一个字符
                count = 1;
                //标记下一个字符
                c = cur;
            }

        }
        //循环结束，拼接最终结果
        sb.append(count);
        sb.append(c);
        //转为字符串并且返回
        String result = sb.toString();
        return result;

    }
}

解法二：哨兵技巧

「哨兵技巧」来简化我们统计的逻辑，避免在循环外统计最后一次字符

class Solution {
    public String countAndSay(int n) {
        /**
         * 你可以将其视作是由递归公式定义的数字字符串序列：
         * countAndSay(1) = "1"
         * countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
         */
        String s = "1";//传入方法的参数
        for (int i = 1; i < n; i++) {
            //调用方法
            s = nextString(s);
        }
        return s;
    }

    //写一个返回字符串的方法
    //传入字符串参数
    private String nextString(String s) {
        //往结尾增加一个"哨兵"
        s += "a";
        //一个可变的字符序列。用于统计与拼接字符串
        StringBuilder sb = new StringBuilder();
        //获取字符串长度
        int n = s.length();
        //将字符串转换为字符数组
        char[] cs = s.toCharArray();
        //标记第一个字符
        char c = cs[0];
        //定义计数器,已经统计一个字符cs[0]
        int count = 1;
        //开始模拟统计,下标从1开始，因为cs[0]已经用 char c=cs[0];标记从cs[1]开始与cs[0]比较是否相同
        for (int i = 1; i < n; i++) {
            //标记当前字符
            char cur = cs[i];
            //相等
            if (c == cur) {
                count++;
            } else {//不相等
                //拼接描述符 数量加字符
                sb.append(count);
                sb.append(c);
                //更新数量以及当前字符统计下一个字符
                count = 1;
                //标记下一个字符
                c = cur;
            }

        }

        //转为字符串并且返回
        String result = sb.toString();
        return result;
    }
}

解法三：双指针

评论区题解

class Solution {
    public String countAndSay(int n) {
        StringBuffer pre = new StringBuffer("1");
        StringBuffer cur = new StringBuffer("1");
        for(int i=1;i<n;i++){
            pre = cur;
            cur = new StringBuffer();
            int start =0,end = 0;
            //开始遍历前一项，开始描述
            while(end<pre.length()){
                while(end<pre.length() && pre.charAt(start) ==pre.charAt(end)){
                    end++;
                }
                //元素出现次数与元素进行拼接
                cur = cur.append(Integer.toString(end-start)).append(pre.charAt(start));
                start = end;
            }

        }
        return cur.toString();
    }
}