1349

Author: mkmark

leetcode/1349/0.in

@@ -0,0 +1 @@
+[["#",".",".",".","#"],[".","#",".","#","."],[".",".","#",".","."],[".","#",".","#","."],["#",".",".",".","#"]]

leetcode/1349/2.in

@@ -0,0 +1 @@
+[[".","#"],["#","#"],["#","."],["#","#"],[".","#"]]

leetcode/1349/51.in

@@ -0,0 +1 @@
+[[".",".",".",".","#",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".","#","."],[".",".",".",".",".",".",".","."],[".",".","#",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","#",".",".","#","."]]

leetcode/1349/main.cpp

@@ -0,0 +1,39 @@
+/*
+author: [email protected]
+*/
+
+#include <bits/stdc++.h>
+#include "../../lib/LeetCodeInputTemplate.hpp"
+#include "solution-2.cpp"
+using namespace std;
+
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+int main()
+{
+    LeetCodeInput li("51.in");
+
+    auto l0 = li.get<vector<vector<char>>>(0);
+
+    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
+    Solution solution;
+    auto output = solution.maxStudents(l0);
+    chrono::steady_clock::time_point end = chrono::steady_clock::now();
+    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds> (end - begin).count() << "µs" << endl;
+
+    cout << output << endl;
+
+    // for (int i: output){
+    //     cout << i << ' ';
+    // }
+
+    // for (auto i: output){
+    //     for (int j: i){
+    //         cout << j << ' ';
+    //     }
+    //     cout << '\n';
+    // }
+
+    return 0;
+}

leetcode/1349/solution-1.cpp

@@ -0,0 +1,97 @@
+/*
+author: [email protected]
+time: O()
+space: O()
+
+Runtime 4 ms Beats 91.1%
+Memory 11.5 MB Beats 24.87%
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+/// @brief dp_max_students[i][status of i] = max students to be deployed later
+uint8_t dp_max_students[8][8][65536];
+/// @brief bit 1 means occupied 
+uint16_t initial_status[8];
+uint8_t m;
+uint8_t n;
+
+class Solution {
+public:
+    int maxStudents(vector<vector<char>>& seats) { 
+        m = size(seats);
+        n = size(seats[0]);
+        int tmp = 1<<(n+8);
+        for (int i=0; i<m; ++i){
+            initial_status[i] = 0;
+            for (int j=0; j<n; ++j){
+                initial_status[i] |= (seats[i][j]=='#')<<j;
+                // fill_n(dp_max_students[i][j], tmp, -1);
+                memset(dp_max_students[i][j], -1, tmp);
+            }
+        }
+        return dfs_max_students(0, 0, (initial_status[0]<<8) + (initial_status[1]));
+    }
+
+    /// @brief 
+    /// @param i 
+    /// @param j 
+    /// @param status status & 1<<(j+8) is current line, status & 1<<j is next line
+    /// @return 
+    int dfs_max_students(uint8_t i, uint8_t j, uint16_t status){
+        if (j>=n){
+            if (i==m-1){
+                return 0;
+            } else {
+                j = 0;
+                ++i;
+                status <<= 8;
+                if (i<m-1){
+                    status |= initial_status[i+1];
+                }
+            }
+        }
+
+        if (dp_max_students[i][j][status] <= 64){
+            return dp_max_students[i][j][status];
+        }
+
+        if ((status & (1 << (j+8))) == 0){
+            int new_status = status;
+            if (i<m-1){
+                if (j) {
+                    new_status |= 1<<j-1;
+                }
+                if (j<n-1) {
+                    new_status |= 1<<j+1;
+                }
+            }
+            if (j) {
+                new_status |= 1<<j+7;
+            }
+            if (j<n-1) {
+                new_status |= 1<<j+9;
+            }
+
+            return dp_max_students[i][j][status] = max(
+                dfs_max_students(i, j+1, status),
+                dfs_max_students(i, j+2, new_status) + 1
+            );
+        } else {
+            return dp_max_students[i][j][status] = dfs_max_students(i, j+1, status);
+        }
+    }
+};
+
+const static auto initialize = [] {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+    return nullptr;
+}();

leetcode/1349/solution-2.cpp

@@ -0,0 +1,80 @@
+/*
+reference: leetcode fastest solution 0ms
+time: O()
+space: O()
+
+Runtime
+Memory
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+class Solution 
+{
+ public:
+  int maxStudents(vector<vector<char>>& seats) 
+  {
+    return accumulate(begin(seats), end(seats), 0,
+                      [&](int a, const auto& seat) 
+                      {
+                        return a + count(begin(seat), end(seat), '.');
+                      }) -
+           hungarian(seats);
+  }
+
+ private:
+  const vector<pair<int, int>> dirs{{-1, -1}, {0, -1}, {1, -1},
+                                    {-1, 1},  {0, 1},  {1, 1}};
+
+  int hungarian(const vector<vector<char>>& seats) 
+  {
+    const int m = seats.size();
+    const int n = seats[0].size();
+    int count = 0;
+    vector<vector<int>> seen(m, vector<int>(n));
+    vector<vector<int>> match(m, vector<int>(n, -1));
+
+    for (int i = 0; i < m; ++i)
+      for (int j = 0; j < n; ++j)
+        if (seats[i][j] == '.' && match[i][j] == -1) 
+        {
+          const int sessionId = i * n + j;
+          seen[i][j] = sessionId;
+          count += dfs(seats, i, j, sessionId, seen, match);
+        }
+
+    return count;
+  }
+
+  int dfs(const vector<vector<char>>& seats, int i, int j, int sessionId,
+          vector<vector<int>>& seen, vector<vector<int>>& match) 
+  {
+    const int m = seats.size();
+    const int n = seats[0].size();
+
+    for (const auto& [dx, dy] : dirs) 
+    {
+      const int x = i + dx;
+      const int y = j + dy;
+      if (x < 0 || x == m || y < 0 || y == n)
+        continue;
+      if (seats[x][y] != '.' || seen[x][y] == sessionId)
+        continue;
+      seen[x][y] = sessionId;
+      if (match[x][y] == -1 || dfs(seats, match[x][y] / n, match[x][y] % n,
+                                   sessionId, seen, match)) {
+        match[x][y] = i * n + j;
+        match[i][j] = x * n + y;
+        return 1;
+      }
+    }
+
+    return 0;
+  }
+};

leetcode/1349/solution.cpp

@@ -0,0 +1,95 @@
+/*
+author: [email protected]
+time: O()
+space: O()
+
+Runtime: 
+Memory Usage: 
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+class Solution {
+public:
+    int m;
+    int n;
+    int res = 0;
+
+    /// @brief 
+    /// '#', 35, broken
+    /// '.', 46, unoccupied
+    /// '*', 42, occupied (extended)
+    ///     <43, unavailable
+    ///    >=43, available
+    char dp_seats[8][8];
+
+    int maxStudents(vector<vector<char>>& seats) {
+        m = size(seats);
+        n = size(seats[0]);
+        for (int i=0; i<m; ++i){
+            for (int j=0; j<n; ++j){
+                dp_seats[i][j] = seats[i][j];
+            }
+        }
+        dfs(m-1, n-1, 0);
+        return res;
+    }
+
+    void dfs(int i, int j, int count){
+        res = max(res, count);
+        if (j==-1){
+            if (i==0){
+                return;
+            } else {
+                j = n-1;
+                --i;
+            }
+        }
+        char a = 0;
+        char b = 0;
+        char c = 0;
+        char d = 0;
+        if (dp_seats[i][j] >= 43){
+            // dp_seats[i][j] = '*';
+            if (i){
+                if (j) {
+                    a = dp_seats[i-1][j-1];
+                    dp_seats[i-1][j-1] = '*';
+                }
+                if (j<n-1) {
+                    b = dp_seats[i-1][j+1];
+                    dp_seats[i-1][j+1] = '*';
+                }
+            }
+            if (j) {
+                c = dp_seats[i][j-1];
+                dp_seats[i][j-1] = '*';
+            }
+            if (j<n-1) {
+                d = dp_seats[i][j+1];
+                dp_seats[i][j+1] = '*';
+            }
+            dfs(i, j-1, count+1);
+            // dp_seats[i][j] = '.';
+            if (a) dp_seats[i-1][j-1] = a;
+            if (b) dp_seats[i-1][j+1] = b;
+            if (c) dp_seats[i][j-1] = c;
+            if (d) dp_seats[i][j+1] = d;
+        }
+
+        dfs(i, j-1, count);
+    }
+};
+
+const static auto initialize = [] {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+    return nullptr;
+}();