LeetCode每日一题(481. Magical String)

A magical string s consists of only ‘1’ and ‘2’ and obeys the following rules:

The string s is magical because concatenating the number of contiguous occurrences of characters ‘1’ and ‘2’ generates the string s itself.
The first few elements of s is s = “1221121221221121122……”. If we group the consecutive 1’s and 2’s in s, it will be “1 22 11 2 1 22 1 22 11 2 11 22 …” and the occurrences of 1’s or 2’s in each group are “1 2 2 1 1 2 1 2 2 1 2 2 …”. You can see that the occurrence sequence is s itself.

Given an integer n, return the number of 1’s in the first n number in the magical string s.

Example 1:

Input: n = 6
Output: 3

Explanation: The first 6 elements of magical string s is “122112” and it contains three 1’s, so return 3.

Example 2:

Input: n = 1
Output: 1

Constraints:

• 1 <= n <= 105

初始化 stack = [1, 2, 2], 初始化 i = 2, 之所以是 2， 是因为[[1], [2, 2]]已经消耗了[1, 2]了， 也就是 stack[0], stack[1]作为数量指示已经被消耗掉了或者被满足了, 我们需要从 stack[2]开始， 当 stack[i] == 1 的时候， 我们需要往 stack 里塞入一个与 stack 中最后一个元素不同的元素， 当 stack[i] == 2 时我们需要向 stack 中塞入两个与 stack 中最后一个元素不同的元素, 剩下的就是根据塞入的值来计数了， 注意这种生成方法可能会超出 n 的值， 但是应为要么塞一个要么塞两个， 所以最多也就超出一个， 最后返回结果的时候对 stack 的长度和最后一个元素做检查即可

impl Solution {
    
    pub fn magical_string(n: i32) -> i32 {
    
        if n <= 3 {
    
            return 1;
        }
        let mut stack = vec![1, 2, 2];
        let mut i = 2;
        let mut ans = 1;
        while stack.len() < n as usize {
    
            if stack[i] == 1 {
    
                if *stack.last().unwrap() == 1 {
    
                    stack.push(2);
                } else {
    
                    stack.push(1);
                    ans += 1;
                }
            } else {
    
                if *stack.last().unwrap() == 1 {
    
                    stack.push(2);
                    stack.push(2);
                } else {
    
                    stack.push(1);
                    stack.push(1);
                    ans += 2;
                }
            }
            i += 1;
        }
        if stack.len() > n as usize {
    
            if stack.last().unwrap() == &1 {
    
                return ans - 1;
            }
        }
        ans
    }
}