leetcode [443]列圧縮

問題：

インプレース圧縮するアルゴリズムを使用して、文字の集合を考えます。

圧縮後の長さは常に未満であるか、または元の配列の長さに等しくなければなりません。

配列の各要素は、1つの文字（整数int型）の長さであるべきです。

入力配列のin situ変更が完了した後、配列の新しい長さを返します。

入力：文字の配列ベクトル<文字>＆文字

出力：文字配列の長さ（同時に、文字の後に、圧縮になること）

アイデア：まず、特別な場合（文字の長さ1、ダイレクトリターン、文字の同じ配列）を処理します。

そして、条件（すなわち、重複したエントリが2以上である）を挿入し、重複の判定回数です。付き！=解決するには1。

ただし、「9」+ 1 =「：」、したがって繰り返して挿入し、さらに処理する変数補助アイテムを数えます。解決するには（int）をTO_STRING付き。

回答：

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）です。

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;
    }
};

、2333年であること、「拳が直面する、4手の」確認の2つのだけのポインタI、重要性のjは、発見するために、上記の回答を参照してください。

答えの上に自分自身を再現すると、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;
    }
};