leetcode[443]string compression

问题：

给定一组字符，使用原地算法将其压缩。

压缩后的长度必须始终小于或等于原数组长度。

数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。

在完成原地修改输入数组后，返回数组的新长度。

输入：字符数组vector<char>& chars

输出：字符数组的长度（同时，chars要变成压缩后的）

思路：首先，处理特殊情况（chars长度为1，直接返回1，chars数组不变）。

然后，判断插入重复项个数的条件（即重复的项大于等于2）。用！=1来解决。

然而，要注意‘9’+1=‘:’，因此计数重复的项的辅助变量要进一步处理下，再插入。用to_string(int)来解决。

解答：

class Solution {
public:
    int compress(vector<char>& chars) {
        int input_len = chars.size();
        if(input_len==1)
        {
            return input_len;
        }
        int num=1;
        for(int i=1; i < input_len; i++)
        {
            if(chars[i-1]!=chars[i])
            {
                if(num==1)
                {
                    continue;
                }
                else
                {
                    string s_num = to_string(num);
                    reverse(s_num.begin(), s_num.end());
                    for(auto s_num_i: s_num)
                    {
                        chars.insert(chars.begin()+i, s_num_i);
                    }
                    num=1;
                }
            }
            else
            {
                chars.erase(chars.begin()+i);
                num = num+1;
            }
            if(i==input_len-1)
            {
                
                if(num=1000)
                {
                    chars.push_back('1');
                    chars.push_back('0');
                    chars.push_back('0');
                    chars.push_back('0');                    
                }
                else
                {
                    string s_num = to_string(num);
                    
                    // reverse(s_num.begin(), s_num.end());
                    cout<<s_num;
                    for(auto s_num_i: s_num)
                    {
                        chars.push_back(s_num_i);
                    }
                }
            }
        }
        int output_len=chars.size();
        return output_len;
    }
};

以上为自己的解答，未AC。无法解决数组下标会随着插入、删除而改变问题。

看了别人的解答，如下，时间复杂度为O(N)，空间复杂度为O(1)，满足in-place要求。

class Solution {
public:
    int compress(vector<char>& chars) {
        int n = chars.size();
        int cur = 0;
        for(int i = 0, j = 0; i < n; j = i) {
            while(i < n && chars[i] == chars[j]) {
                i++;
            }
            chars[cur++] = chars[j];
            if(i - j == 1) {
                continue;
            }
            string s = to_string(i - j);
            for(int t = 0; t < s.size(); t++) {
                chars[cur++] = s[t];
            }
        }
        return cur;
    }
};

看了以上答案，才发觉两个指针i，j的重要性，印证了“双拳难敌四手”这句话，2333。

自己复现上述答案时，AC不了，原因见下方答案注释。

class Solution {
public:
    int compress(vector<char>& chars) {
        int len_input;
        len_input = chars.size();
        int cur = 0;
        int num;
        string s_num;
        int i=0,j=0;
        for(; i<len_input; j=i)
        {
            while(i<len_input&&chars[i]==chars[j])
            {
                i++;
            }
            chars[cur++]=chars[j];
            num = i-j;
            if(num==1)
            {
                continue;
            }
            s_num = to_string(num);
            for(auto s_i:s_num)
            {
                chars[cur++]=s_i;
            }
        }
        int len_output=chars.size();  # 这样会返回与原数组相同长度的数组
        return len_output;
    }
};