From 51a6234dc9fddf173e29262017ac8cd92ee89b7c Mon Sep 17 00:00:00 2001 From: Lam Haoyin Date: Sun, 13 Feb 2022 00:14:11 +0800 Subject: [PATCH] add: 220212 --- 2202/220212-CN.cpp | 108 ++++++++++++++++++++++++++++++++++++++++++++ 2202/220212.cpp | 92 +++++++++++++++++++++++++++++++++++++ 2202/CMakeLists.txt | 2 +- 3 files changed, 201 insertions(+), 1 deletion(-) create mode 100644 2202/220212-CN.cpp create mode 100644 2202/220212.cpp diff --git a/2202/220212-CN.cpp b/2202/220212-CN.cpp new file mode 100644 index 0000000..4d05a07 --- /dev/null +++ b/2202/220212-CN.cpp @@ -0,0 +1,108 @@ +#include +#include +#include +#include +#include +#include + +/** + * 1020. Number of Enclaves + * You are given an m x n binary matrix grid, where 0 represents a sea cell and 1 represents a land cell. + * A move consists of walking from one land cell to another adjacent (4-directionally) land cell or walking off the boundary of the grid. + * Return the number of land cells in grid for which we cannot walk off the boundary of the grid in any number of moves. + */ + +class Solution { +private: + inline static const int dX[] = {0, 1, 0, -1}; + inline static const int dY[] = {1, 0, -1, 0}; + inline static constexpr bool isValid(int x, int y, int m, int n) { + return (x >= 0) && (y >= 0) && (x < m) && (y < n); + } + inline static constexpr bool isEdge(int x, int y, int m, int n) { + return (!x) || (!y) || (x == m - 1) || (y == n - 1); + } +public: + static int numEnclaves(std::vector>& grid) { + int m = grid.size(), n = grid.back().size(); + int s = m * n * 2 + 100; + int* const q = new int[s]; + bool* const vis = new bool[m * n]{}; + int f = 0, r = 0; + + for (int i = 0; i < m; ++i) { + const auto& t = grid[i]; + if (t[0]) { + q[r++] = i; + q[r++] = 0; + vis[i * n] = true; + } + if (t[n - 1]) { + q[r++] = i; + q[r++] = n - 1; + vis[i * n + (n - 1)] = true; + } + } + + const auto& tf = grid[0]; + for (int i = 0; i < n; ++i) { + if (tf[i]) { + q[r++] = 0; + q[r++] = i; + vis[i] = true; + } + } + + const auto& tb = grid[m - 1]; + for (int i = 0; i < n; ++i) { + if (tb[i]) { + q[r++] = m - 1; + q[r++] = i; + vis[(m - 1) * n + i] = true; + } + } + + while (f < r) { + int x = q[f++]; + int y = q[f++]; + grid[x][y] = 0; + for (int i = 0; i < 4; ++i) { + int nx = x + dX[i], ny = y + dY[i]; + if (isValid(nx, ny, m, n) && !vis[nx * n + ny] && grid[nx][ny]) { + q[r++] = nx; + q[r++] = ny; + vis[nx * n + ny] = true; + } + } + } + + int ret = 0; + for (int i = 0; i < m; ++i) + for (int j = 0; j < n; ++j) + ret += grid[i][j]; + + delete[] q; + delete[] vis; + return ret; + } +}; + +int main() { + const int SIZE = 500; + std::mt19937 r(std::time(nullptr)); + std::vector> args; + args.reserve(SIZE); + for (int i = 0; i < SIZE; ++i) { + args.emplace_back(); + auto& t = args.back(); + t.reserve(SIZE); + for (int j = 0; j < SIZE; ++j) + t.push_back(1); + } + const auto start = std::chrono::high_resolution_clock::now(); + int ans = Solution::numEnclaves(args); + const auto end = std::chrono::high_resolution_clock::now(); + std::cout << ans << std::endl; + std::cout << std::chrono::duration_cast(end - start).count() << " ms.\n"; + return 0; +} diff --git a/2202/220212.cpp b/2202/220212.cpp new file mode 100644 index 0000000..c4c546b --- /dev/null +++ b/2202/220212.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include + +/** + * 127. Word Ladder + * A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s[1] -> s[2] -> ... -> s[k] such that: + * Every adjacent pair of words differs by a single letter. + * Every s[i] for 1 <= i <= k is in wordList. Note that beginWord does not need to be in wordList. + * s[k] == endWord + * Given two words, beginWord and endWord, and a dictionary wordList, return the number of words in the shortest transformation sequence from beginWord to endWord, or 0 if no such sequence exists. + */ + +class Solution { +private: + // Assume s is same length as t. + static inline bool isDist1(const std::string& s, const std::string& t) { + int n = s.length(); + bool c = 0; + for (int i = 0; i < n; ++i) { + if (s[i] != t[i]) { + if (c) + return false; + else + c = true; + } + } + return c; + } +public: + static int ladderLength(const std::string& beginWord, const std::string& endWord, const std::vector& wordList) { + int reachable = -1, n = wordList.size(); + for (int i = 0; i < n; ++i) { + if (wordList[i] == endWord) { + reachable = i; + break; + } + } + if (reachable == -1) + return 0; + + std::vector> G; + G.reserve(wordList.size()); + for (int i = 0; i < n; ++i) + G.emplace_back(); + for (int i = 0; i < n; ++i) { + for (int j = i + 1; j < n; ++j) { + if (isDist1(wordList[i], wordList[j])) { + G[j].push_back(i); + G[i].push_back(j); + } + } + } + + bool* const vis = new bool[n]{}; + std::queue q; + for (int i = 0; i < n; ++i) { + if (isDist1(beginWord, wordList[i])) { + q.push(i); + q.push(2); + vis[i] = true; + } + } + + while (!q.empty()) { + int idx = q.front(); + q.pop(); + int depth = q.front(); + q.pop(); + if (reachable == idx) { + delete[] vis; + return depth; + } + for (int i : G[idx]) { + if (!vis[i]) { + q.push(i); + q.push(1 + depth); + vis[i] = true; + } + } + } + + delete[] vis; + return 0; + } +}; + +int main() { + std::cout << Solution::ladderLength("hit", "cog", {"hot","dot","dog","lot","log","cog"}); + return 0; +} \ No newline at end of file diff --git a/2202/CMakeLists.txt b/2202/CMakeLists.txt index 6c96c64..5172c6e 100644 --- a/2202/CMakeLists.txt +++ b/2202/CMakeLists.txt @@ -3,4 +3,4 @@ PROJECT(2202) SET(CMAKE_CXX_STANDARD 23) -ADD_EXECUTABLE(2202 220210.cpp) +ADD_EXECUTABLE(2202 220212.cpp)