Add files via upload

Author: kerong2002

C++/0211. Design Add and Search Words Data Structure.cpp

@@ -0,0 +1,59 @@
+class TrieNode {
+public:
+    TrieNode* child[26];
+    bool isWord;
+    TrieNode() {
+        isWord = false;
+        for (auto& c : child) {
+            c = nullptr;
+        }
+    }
+};
+
+class WordDictionary {
+    TrieNode* root;
+public:
+    WordDictionary() {
+        root = new TrieNode();
+    }
+    
+    void addWord(string word) {
+        TrieNode* node = root;
+        for (char& c : word) {
+            int i = c - 'a';
+            if (!node->child[i]) {
+                node->child[i] = new TrieNode();
+            }
+            node = node->child[i];
+        }
+        node->isWord = true;
+    }
+    
+    bool help(const string& word, int pos, TrieNode* node) {
+        if (pos == word.size()) {
+            return node->isWord;
+        }
+        char c = word[pos];
+        int token = c - 'a';
+        if (c != '.') {
+            return node -> child[token] != nullptr && help(word, pos + 1, node->child[token]);
+        }
+        for (int i = 0; i < 26; i++) {
+            if (node->child[i] != nullptr && help(word, pos + 1, node->child[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool search(string word) {
+       return help(word, 0, root);
+    }
+};
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary* obj = new WordDictionary();
+ * obj->addWord(word);
+ * bool param_2 = obj->search(word);
+ */

C++/0212. Word Search II.cpp

@@ -0,0 +1,83 @@
+class TrieNode {
+public:
+    bool isWord;
+    TrieNode* child[26];
+
+    TrieNode() {
+        isWord = false;
+        for (auto& c : child) {
+            c = nullptr;
+        }
+    }
+};
+
+class Solution {
+    int row;
+    int col;
+    TrieNode* root;
+public:
+    void addWord(string word) {
+        TrieNode* node = root;
+        for (char& c : word) {
+            int i = c - 'a';
+            if (!node->child[i]) {
+                node->child[i] = new TrieNode();
+            }
+            node = node->child[i];
+        }
+        node->isWord = true;
+    }
+
+    void dfs(const vector<vector<char>>& board, int y, int x, TrieNode* node, string word, vector<vector<bool>>& visit, vector<string>& ans) {
+        if (x < 0 || y < 0 || x >= col || y >= row || visit[y][x] == true) {
+            return;
+        }
+
+        char c = board[y][x];
+        int token = c - 'a';
+
+        node = node->child[token];
+
+        if (!node) {
+            return;
+        }
+
+        word += board[y][x];
+
+        if (node->isWord) {
+            ans.push_back(word);
+            node->isWord = false;  // Mark the word as found
+        }
+
+       
+        visit[y][x] = true;
+        dfs(board, y - 1, x    , node, word, visit, ans);
+        dfs(board, y    , x + 1, node, word, visit, ans);
+        dfs(board, y + 1, x    , node, word, visit, ans);
+        dfs(board, y    , x - 1, node, word, visit, ans);
+        visit[y][x] = false;
+    }
+
+
+    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
+        vector<string> ans;
+        row = board.size();
+        col = board[0].size();
+
+        root = new TrieNode();
+
+        for (string& str : words) {
+            addWord(str);
+        }
+        
+        string key;
+        vector<vector<bool>> visit(row, vector<bool>(col, false));
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                dfs(board, i, j, root, key, visit, ans);
+            }
+        }
+
+        return ans;
+    }
+};

C++/0421. Maximum XOR of Two Numbers in an Array.cpp

@@ -0,0 +1,59 @@
+
+class TrieNode {
+public:
+    bool isEnd;
+    TrieNode* child[2];
+    TrieNode() {
+        isEnd = false;
+        for (auto& c : child) {
+            c = nullptr;
+        }
+    }
+};
+class Solution {
+    TrieNode* root;
+public:
+    void addNum(int num) {
+        TrieNode* node = root;
+        int token = 0;
+        for (int i = 31; i >= 0; i--) {
+            token = (num >> i) & 1;
+            if (!node->child[token]) {
+                node->child[token] = new TrieNode();
+            }
+            node = node->child[token];
+        }
+    }
+
+    int search(int num) {
+        int sum = 0;
+        TrieNode* node = root;
+        for (int i = 31; i >= 0; i--) {
+            int key = (num >> i) & 1;
+            int other = key ? 0 : 1;
+            if (!node->child[other]) {
+                node = node->child[key];
+            }
+            else {
+                sum += (1 << i);
+                node = node->child[other];
+            }
+        }
+        return sum;
+    }
+
+    int findMaximumXOR(vector<int>& nums) {
+        root = new TrieNode();
+        for (const auto& n : nums) {
+            addNum(n);
+        }
+
+        int ans = 0;
+        for (const auto& n : nums) {
+            ans = max(ans, search(n));
+        }
+
+        return ans;
+    } 
+};
+

C++/1707. Maximum XOR With an Element From Array.cpp

@@ -0,0 +1,77 @@
+
+class TrieNode {
+public:
+    TrieNode* child[2];
+    TrieNode() {
+        for (auto& c : child) {
+            c = nullptr;
+        }
+    }
+};
+
+bool cmp(vector<int>&a, vector<int>& b) {
+    return a[1] < b[1];
+}
+
+class Solution {
+    TrieNode* root;
+    
+public:
+
+    void addNum(int num) {
+        TrieNode* node = root;
+        int token = 0;
+        for (int i = 31; i >= 0; i--) {
+            token = (num >> i) & 1;
+            if (!node->child[token]) {
+                node->child[token] = new TrieNode();
+            }
+            node = node->child[token];
+        }
+    }
+
+    int search(int num) {
+        int sum = 0;
+        TrieNode* node = root;
+        for (int i = 31; i >= 0; i--) {
+            int key = (num >> i) & 1;
+            int other = key ? 0 : 1;
+            if (!node->child[other]) {
+                node = node->child[key];
+            }
+            else {
+                sum += (1 << i);
+                node = node->child[other];
+            }
+        }
+        return sum;
+    }
+
+    vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
+        root = new TrieNode();
+        
+        vector<int> ans(queries.size(), -1);
+
+        for (int i = 0; i < queries.size(); i++) {
+            queries[i].push_back(i);
+        }
+
+        sort(nums.begin(), nums.end());
+        sort(queries.begin(), queries.end(), cmp);
+
+        int pos = 0;
+        for (int i = 0; i < queries.size(); i++) {
+            while (pos < nums.size() && nums[pos] <= queries[i][1]) {
+                addNum(nums[pos]);
+                pos += 1;
+            }
+            cout << "yes";
+            if (pos != 0) {
+                ans[queries[i][2]] = search(queries[i][0]);
+            }
+        }
+
+
+        return ans;
+    }
+};

C++/2416. Sum of Prefix Scores of Strings.cpp

@@ -0,0 +1,65 @@
+
+class TrieNode {
+public:
+    TrieNode* child[26];
+    int num;
+    TrieNode() {
+        num = 0;
+        for (auto& c : child) {
+            c = nullptr;
+        }
+    }
+};
+
+class Trie {
+    TrieNode* root;
+public:
+    Trie() {
+       root = new TrieNode();
+    }
+
+    void insert(string word) {
+        TrieNode* node = root;
+        for (char& c : word) {
+            int i = c - 'a';
+            if (!node->child[i]) {
+                node->child[i] = new TrieNode();
+            }
+            node = node->child[i];
+            node->num += 1;
+        }
+    }
+
+    int search(string word) {
+        TrieNode* node = root;
+        int sum = 0;
+        for (char& c : word) {
+            int i = c - 'a';
+            if (!node->child[i]) {
+                return -1;
+            }
+            node = node->child[i];
+            sum += node->num;
+        }
+        return sum;
+    }
+
+
+};
+
+class Solution {
+public:
+    vector<int> sumPrefixScores(vector<string>& words) {
+        vector<int> ans(words.size(), 0);
+        Trie t;
+
+        for (int i = 0; i < words.size(); i++) {
+            t.insert(words[i]);
+        }
+
+        for (int i = 0; i < words.size(); i++) {
+            ans[i] = t.search(words[i]);
+        }
+        return ans;
+    }
+};

C++/2530. Maximal Score After Applying K Operations.cpp

@@ -0,0 +1,24 @@
+class Solution {
+    long long ans;
+public:
+    void cal(int& k, priority_queue<int> v) {  // 注意：這裡傳值而不是引用
+        int n = 0;
+        while (k) {
+            // cout << v.top() << ' ';
+            n = v.top();
+            ans += n;
+            v.pop();
+            v.push(ceil(n / 3.0));
+            k--;
+        }
+        // cout << '\n';
+    }
+
+    long long maxKelements(vector<int>& nums, int k) {
+        ans = 0;
+        priority_queue<int> pq(nums.begin(), nums.end());
+        cal(k, pq);
+
+        return ans;
+    }
+};