feat: add solutions to lc problem: No.1820

No.1820.Maximum Number of Accepted Invitations

Author: yanglbme

solution/1800-1899/1820.Maximum Number of Accepted Invitations/README.md

@@ -53,22 +53,148 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：匈牙利算法**
+
+本题属于二分图最大匹配问题，适合用匈牙利算法来求解。
+
+匈牙利算法的核心思想是，不断地从未匹配的点出发，寻找增广路径，直到没有增广路径为止，就得到了最大匹配。
+
+时间复杂度 $O(m\times n)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maximumInvitations(self, grid: List[List[int]]) -> int:
+        def find(i):
+            for j, v in enumerate(grid[i]):
+                if v and j not in vis:
+                    vis.add(j)
+                    if match[j] == -1 or find(match[j]):
+                        match[j] = i
+                        return True
+            return False
+
+        m, n = len(grid), len(grid[0])
+        match = [-1] * n
+        ans = 0
+        for i in range(m):
+            vis = set()
+            ans += find(i)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[][] grid;
+    private boolean[] vis;
+    private int[] match;
+    private int n;
+
+    public int maximumInvitations(int[][] grid) {
+        int m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        vis = new boolean[n];
+        match = new int[n];
+        Arrays.fill(match, -1);
+        int ans = 0;
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(vis, false);
+            if (find(i)) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+
+    private boolean find(int i) {
+        for (int j = 0; j < n; ++j) {
+            if (grid[i][j] == 1 && !vis[j]) {
+                vis[j] = true;
+                if (match[j] == -1 || find(match[j])) {
+                    match[j] = i;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maximumInvitations(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        bool vis[210];
+        int match[210];
+        memset(match, -1, sizeof match);
+        int ans = 0;
+        function<bool(int)> find = [&](int i) -> bool {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] && !vis[j]) {
+                    vis[j] = true;
+                    if (match[j] == -1 || find(match[j])) {
+                        match[j] = i;
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        for (int i = 0; i < m; ++i) {
+            memset(vis, 0, sizeof vis);
+            ans += find(i);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumInvitations(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	var vis map[int]bool
+	match := make([]int, n)
+	for i := range match {
+		match[i] = -1
+	}
+	var find func(i int) bool
+	find = func(i int) bool {
+		for j, v := range grid[i] {
+			if v == 1 && !vis[j] {
+				vis[j] = true
+				if match[j] == -1 || find(match[j]) {
+					match[j] = i
+					return true
+				}
+			}
+		}
+		return false
+	}
+	ans := 0
+	for i := 0; i < m; i++ {
+		vis = map[int]bool{}
+		if find(i) {
+			ans++
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/1800-1899/1820.Maximum Number of Accepted Invitations/README_EN.md

@@ -54,13 +54,131 @@ Explanation:</strong> The invitations are sent as follows:
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maximumInvitations(self, grid: List[List[int]]) -> int:
+        def find(i):
+            for j, v in enumerate(grid[i]):
+                if v and j not in vis:
+                    vis.add(j)
+                    if match[j] == -1 or find(match[j]):
+                        match[j] = i
+                        return True
+            return False
+
+        m, n = len(grid), len(grid[0])
+        match = [-1] * n
+        ans = 0
+        for i in range(m):
+            vis = set()
+            ans += find(i)
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private int[][] grid;
+    private boolean[] vis;
+    private int[] match;
+    private int n;
+
+    public int maximumInvitations(int[][] grid) {
+        int m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        vis = new boolean[n];
+        match = new int[n];
+        Arrays.fill(match, -1);
+        int ans = 0;
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(vis, false);
+            if (find(i)) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+
+    private boolean find(int i) {
+        for (int j = 0; j < n; ++j) {
+            if (grid[i][j] == 1 && !vis[j]) {
+                vis[j] = true;
+                if (match[j] == -1 || find(match[j])) {
+                    match[j] = i;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maximumInvitations(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        bool vis[210];
+        int match[210];
+        memset(match, -1, sizeof match);
+        int ans = 0;
+        function<bool(int)> find = [&](int i) -> bool {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] && !vis[j]) {
+                    vis[j] = true;
+                    if (match[j] == -1 || find(match[j])) {
+                        match[j] = i;
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        for (int i = 0; i < m; ++i) {
+            memset(vis, 0, sizeof vis);
+            ans += find(i);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumInvitations(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	var vis map[int]bool
+	match := make([]int, n)
+	for i := range match {
+		match[i] = -1
+	}
+	var find func(i int) bool
+	find = func(i int) bool {
+		for j, v := range grid[i] {
+			if v == 1 && !vis[j] {
+				vis[j] = true
+				if match[j] == -1 || find(match[j]) {
+					match[j] = i
+					return true
+				}
+			}
+		}
+		return false
+	}
+	ans := 0
+	for i := 0; i < m; i++ {
+		vis = map[int]bool{}
+		if find(i) {
+			ans++
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/1800-1899/1820.Maximum Number of Accepted Invitations/Solution.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int maximumInvitations(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        bool vis[210];
+        int match[210];
+        memset(match, -1, sizeof match);
+        int ans = 0;
+        function<bool(int)> find = [&](int i) -> bool {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] && !vis[j]) {
+                    vis[j] = true;
+                    if (match[j] == -1 || find(match[j])) {
+                        match[j] = i;
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        for (int i = 0; i < m; ++i) {
+            memset(vis, 0, sizeof vis);
+            ans += find(i);
+        }
+        return ans;
+    }
+};

solution/1800-1899/1820.Maximum Number of Accepted Invitations/Solution.go

@@ -0,0 +1,29 @@
+func maximumInvitations(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	var vis map[int]bool
+	match := make([]int, n)
+	for i := range match {
+		match[i] = -1
+	}
+	var find func(i int) bool
+	find = func(i int) bool {
+		for j, v := range grid[i] {
+			if v == 1 && !vis[j] {
+				vis[j] = true
+				if match[j] == -1 || find(match[j]) {
+					match[j] = i
+					return true
+				}
+			}
+		}
+		return false
+	}
+	ans := 0
+	for i := 0; i < m; i++ {
+		vis = map[int]bool{}
+		if find(i) {
+			ans++
+		}
+	}
+	return ans
+}

solution/1800-1899/1820.Maximum Number of Accepted Invitations/Solution.java

@@ -0,0 +1,36 @@
+class Solution {
+    private int[][] grid;
+    private boolean[] vis;
+    private int[] match;
+    private int n;
+
+    public int maximumInvitations(int[][] grid) {
+        int m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        vis = new boolean[n];
+        match = new int[n];
+        Arrays.fill(match, -1);
+        int ans = 0;
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(vis, false);
+            if (find(i)) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+
+    private boolean find(int i) {
+        for (int j = 0; j < n; ++j) {
+            if (grid[i][j] == 1 && !vis[j]) {
+                vis[j] = true;
+                if (match[j] == -1 || find(match[j])) {
+                    match[j] = i;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

solution/1800-1899/1820.Maximum Number of Accepted Invitations/Solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def maximumInvitations(self, grid: List[List[int]]) -> int:
+        def find(i):
+            for j, v in enumerate(grid[i]):
+                if v and j not in vis:
+                    vis.add(j)
+                    if match[j] == -1 or find(match[j]):
+                        match[j] = i
+                        return True
+            return False
+
+        m, n = len(grid), len(grid[0])
+        match = [-1] * n
+        ans = 0
+        for i in range(m):
+            vis = set()
+            ans += find(i)
+        return ans