387. First Unique Character in a String

arai60/first-unique-character-in-a-string/README.md

@@ -0,0 +1,45 @@
+## 考察
+- 過去に解いたことあり(覚えていない)
+- 方針
+    - ソートして見ていく
+        - ソートすることにより同じ文字は隣合う
+        - 元のインデックスを保持しておく必要あり
+        - time: O(n lon n), space: O(n log n) -> time, spaceともにソートの分
+    - 度数分布を取得してループ
+        - これも元のインデックスを保持する必要ありそう
+            - もしかしたらC++のunordered_mapは挿入順を保持する？
+                - わからないのでドキュメント確認する必要
+                - さくっと調べたが特にそのような記載は見当たらなかった
+                    - https://en.cppreference.com/w/cpp/container/unordered_map
+        - time: O(n), space: O(n)
+- 下の方針で行く
+- あとは実装
+
+## Step1
+- 上で考えたアルゴリズムを実装
+- time: O(n), space: O(n)
+
+## Step2
+- 他の人のPRを検索
+- Javaには順序のあるHashMapがあるらしい、平衡木を使う方法もある
+    - Ref. https://github.com/Ryotaro25/leetcode_first60/pull/16/files#r1642839594
+
+- Pythonのdictは挿入順序を保持するみたい
+    - Ref. https://github.com/nittoco/leetcode/pull/20/files#diff-c6374213bbbe17c2850ccd0bfb422c1f5bf40576b93320647cbfd9e9e3724c74R48
+
+- 文字列を2回走査すれば、インデックスを保持する必要はなかった
+    - これは思いつかなかった
+    - 時間的にも十分だし、一番シンプル
+    - https://github.com/nittoco/leetcode/pull/20/files#diff-c6374213bbbe17c2850ccd0bfb422c1f5bf40576b93320647cbfd9e9e3724c74R119
+
+- 上記を考慮して、C++なら文字列を2回走査するのが一番シンプルだと思ったので修正
+
+## Step3
+- 1回目: 55s
+- 2回目: 50s
+- 3回目: 50s
+
+## Step4
+- 平衡木とソートを使った実装を追加した
+    - `step4_balanced_bst.cpp`
+    - `step4_sorting.cpp`

arai60/first-unique-character-in-a-string/step1.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        unordered_map<char, Count> char_to_count;
+        for (int i = 0; i < s.size(); ++i) {
+            char_to_count[s[i]].count++;
+            char_to_count[s[i]].index = i;
+        }
+
+        int answer = INT_MAX;
+        for (const auto& [character, count]: char_to_count) {
+            if (count.count == 1) {
+                answer = min(answer, count.index);
+            }
+        }
+
+        if (answer == INT_MAX) {
+            return -1;
+        }
+        return answer;
+    }
+
+private:
+    struct Count {
+        int count;
+        int index;
+    };
+};

arai60/first-unique-character-in-a-string/step2.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        unordered_map<char, int> char_to_count;
+        for (int i = 0; i < s.size(); i++) {
+            char_to_count[s[i]]++;
+        }
+
+        for (int i = 0; i < s.size(); i++) {
+            if (char_to_count[s[i]] == 1) return i;
+        }
+        return -1;
+    }
+};

arai60/first-unique-character-in-a-string/step3.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        unordered_map<char, int> char_to_count;
+        for (int i = 0; i < s.size(); i++) {
+            char_to_count[s[i]]++;
+        }
+        for (int i = 0; i < s.size(); i++) {
+            if (char_to_count[s[i]] == 1) return i;
+        }
+        return -1;
+    }
+};

arai60/first-unique-character-in-a-string/step4_balanced_bst.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        map<int, char> first_index_to_char;
+        unordered_map<char, int> char_to_first_index;
+        for (int i = 0; i < s.size(); i++) {
+            if (char_to_first_index.find(s[i]) != char_to_first_index.end()) {
+                first_index_to_char.erase(char_to_first_index[s[i]]);
+                continue;
+            }
+            first_index_to_char[i] = s[i];
+            char_to_first_index[s[i]] = i;
+        }
+
+        return !first_index_to_char.empty() ? first_index_to_char.begin()->first : -1;
+    }
+};

arai60/first-unique-character-in-a-string/step4_sorting.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        vector<Character> s_with_index;
+        for (int i = 0; i < s.size(); i++) {
+            s_with_index.push_back({s[i], i});
+        }
+        sort(s_with_index.begin(), s_with_index.end(), [](const Character& a, const Character& b) {
+            return a.character < b.character;
+        });
+
+        int count = 1;
+        int answer = numeric_limits<int>::max();
+        for (int i = 0; i < s_with_index.size(); i++) {
+            if (i < s_with_index.size() - 1 && s_with_index[i].character == s_with_index[i + 1].character) {
+                count++;
+                continue;
+            }
+            if (count == 1) {
+                answer = min(answer, s_with_index[i].index);
+            }
+            count = 1;
+        }
+
+        return answer != numeric_limits<int>::max() ? answer : -1;
+    }
+
+private:
+    struct Character {
+        char character;
+        int index;
+    };
+};