@@ -74,7 +74,17 @@ The compatibility score sum is 3 + 2 + 3 = 8.
7474
7575<!-- solution:start -->
7676
77- ### Solution 1
77+ ### Solution 1: Preprocessing + Backtracking
78+
79+ We can first preprocess the compatibility score $g[ i] [ j ] $ between each student $i$ and mentor $j$, and then use a backtracking algorithm to solve the problem.
80+
81+ Define a function $\textit{dfs}(i, s)$, where $i$ represents the current student being processed, and $s$ represents the current sum of compatibility scores.
82+
83+ In $\textit{dfs}(i, s)$, if $i \geq m$, it means all students have been assigned, and we update the answer to $\max(\textit{ans}, s)$. Otherwise, we enumerate which mentor the $i$-th student can be assigned to, and then recursively process the next student. During the process, we use an array $\textit{vis}$ to record which mentors have already been assigned to avoid duplicate assignments.
84+
85+ We call $\textit{dfs}(0, 0)$ to get the maximum compatibility score sum.
86+
87+ The time complexity is $O(m!)$, and the space complexity is $O(m^2)$. Here, $m$ is the number of students and mentors.
7888
7989<!-- tabs:start -->
8090
@@ -85,24 +95,24 @@ class Solution:
8595 def maxCompatibilitySum (
8696 self students : List[List[int ]], mentors : List[List[int ]]
8797 ) -> int :
88- def dfs (i , t ):
89- if i = =
98+ def dfs (i : int , s : int ):
99+ if i > =
90100 nonlocal ans
91- ans = max (ans, t )
101+ ans = max (ans, s )
92102 return
93103 for j in range (m):
94104 if not vis[j]:
95105 vis[j] = True
96- dfs(i + 1 , t + g[i][j])
106+ dfs(i + 1 , s + g[i][j])
97107 vis[j] = False
98108
109+ ans = 0
99110 m = len (students)
100- g = [[0 ] * m for _ in range (m)]
101- for i in range (m):
102- for j in range (m):
103- g[i][j] = sum (a == b for a, b in zip (students[i], mentors[j]))
104111 vis = [False ] * m
105- ans = 0
112+ g = [[0 ] * m for _ in range (m)]
113+ for i, x in enumerate (students):
114+ for j, y in enumerate (mentors):
115+ g[i][j] = sum (a == b for a, b in zip (x, y))
106116 dfs(0 , 0 )
107117 return ans
108118```
@@ -111,10 +121,10 @@ class Solution:
111121
112122``` java
113123class Solution {
114- private int [][] g;
115- private boolean [] vis;
116124 private int m;
117125 private int ans;
126+ private int [][] g;
127+ private boolean [] vis;
118128
119129 public int maxCompatibilitySum (int [][] students , int [][] mentors ) {
120130 m = students. length;
@@ -123,23 +133,25 @@ class Solution {
123133 for (int i = 0 ; i < m; ++ i) {
124134 for (int j = 0 ; j < m; ++ j) {
125135 for (int k = 0 ; k < students[i]. length; ++ k) {
126- g[i][j] += students[i][k] == mentors[j][k] ? 1 : 0 ;
136+ if (students[i][k] == mentors[j][k]) {
137+ ++ g[i][j];
138+ }
127139 }
128140 }
129141 }
130142 dfs(0 , 0 );
131143 return ans;
132144 }
133145
134- private void dfs (int i , int t ) {
135- if (i = =
136- ans = Math . max(ans, t );
146+ private void dfs (int i , int s ) {
147+ if (i > =
148+ ans = Math . max(ans, s );
137149 return ;
138150 }
139151 for (int j = 0 ; j < m; ++ j) {
140152 if (! vis[j]) {
141153 vis[j] = true ;
142- dfs(i + 1 , t + g[i][j]);
154+ dfs(i + 1 , s + g[i][j]);
143155 vis[j] = false ;
144156 }
145157 }
@@ -155,10 +167,8 @@ public:
155167 int maxCompatibilitySum(vector<vector<int >>& students, vector<vector<int >>& mentors) {
156168 int m = students.size();
157169 int n = students[ 0] .size();
158- int g[ m] [ m ] ;
159- memset(g, 0, sizeof g);
160- bool vis[ m] ;
161- memset(vis, 0, sizeof vis);
170+ vector<vector<int >> g(m, vector<int >(m));
171+ vector<bool > vis(m);
162172 for (int i = 0; i < m; ++i) {
163173 for (int j = 0; j < m; ++j) {
164174 for (int k = 0; k < n; ++k) {
@@ -167,15 +177,15 @@ public:
167177 }
168178 }
169179 int ans = 0;
170- function<void(int, int)> dfs = [ &] (int i, int t ) {
171- if (i = = m) {
172- ans = max(ans, t );
180+ auto dfs = [ &] (this auto&& dfs, int i, int s ) {
181+ if (i > = m) {
182+ ans = max(ans, s );
173183 return;
174184 }
175185 for (int j = 0; j < m; ++j) {
176186 if (!vis[ j] ) {
177187 vis[ j] = true;
178- dfs(i + 1, t + g[ i] [ j ] );
188+ dfs(i + 1, s + g[ i] [ j ] );
179189 vis[ j] = false;
180190 }
181191 }
@@ -193,26 +203,26 @@ func maxCompatibilitySum(students [][]int, mentors [][]int) (ans int) {
193203 m, n := len(students), len(students[0])
194204 g := make([][]int, m)
195205 vis := make([]bool, m)
196- for i := range g {
206+ for i, x := range students {
197207 g[i] = make([]int, m)
198- for j := range g {
208+ for j, y := range mentors {
199209 for k := 0; k < n; k++ {
200- if students[i][ k] == mentors[j] [k] {
210+ if x[ k] == y [k] {
201211 g[i][j]++
202212 }
203213 }
204214 }
205215 }
206216 var dfs func(int, int)
207- dfs = func(i, t int) {
217+ dfs = func(i, s int) {
208218 if i == m {
209- ans = max(ans, t )
219+ ans = max(ans, s )
210220 return
211221 }
212222 for j := 0; j < m; j++ {
213223 if !vis[j] {
214224 vis[j] = true
215- dfs(i+1, t +g[i][j])
225+ dfs(i+1, s +g[i][j])
216226 vis[j] = false
217227 }
218228 }
@@ -222,6 +232,124 @@ func maxCompatibilitySum(students [][]int, mentors [][]int) (ans int) {
222232}
223233```
224234
235+ #### TypeScript
236+
237+ ``` ts
238+ function maxCompatibilitySum(students : number [][], mentors : number [][]): number {
239+ let ans = 0 ;
240+ const = students .length ;
241+ const : boolean [] = Array (m ).fill (false );
242+ const : number [][] = Array .from ({ length: m }, () => Array (m ).fill (0 ));
243+ for (let i = 0 ; i < m ; ++ i ) {
244+ for (let j = 0 ; j < m ; ++ j ) {
245+ for (let k = 0 ; k < students [i ].length ; ++ k ) {
246+ if (students [i ][k ] === mentors [j ][k ]) {
247+ g [i ][j ]++ ;
248+ }
249+ }
250+ }
251+ }
252+ const = (i : number , s : number ): void => {
253+ if (i >= m ) {
254+ ans = Math .max (ans , s );
255+ return ;
256+ }
257+ for (let j = 0 ; j < m ; ++ j ) {
258+ if (! vis [j ]) {
259+ vis [j ] = true ;
260+ dfs (i + 1 , s + g [i ][j ]);
261+ vis [j ] = false ;
262+ }
263+ }
264+ };
265+ dfs (0 , 0 );
266+ return ans ;
267+ }
268+ ```
269+
270+ #### Rust
271+
272+ ``` rust
273+ impl Solution {
274+ pub fn max_compatibility_sum (students : Vec <Vec <i32 >>, mentors : Vec <Vec <i32 >>) -> i32 {
275+ let mut ans = 0 ;
276+ let m = students . len ();
277+ let mut vis = vec! [false ; m ];
278+ let mut g = vec! [vec! [0 ; m ]; m ];
279+
280+ for i in 0 .. m {
281+ for j in 0 .. m {
282+ for k in 0 .. students [i ]. len () {
283+ if students [i ][k ] == mentors [j ][k ] {
284+ g [i ][j ] += 1 ;
285+ }
286+ }
287+ }
288+ }
289+
290+ fn dfs (i : usize , s : i32 , m : usize , g : & Vec <Vec <i32 >>, vis : & mut Vec <bool >, ans : & mut i32 ) {
291+ if i >= m {
292+ * ans = (* ans ). max (s );
293+ return ;
294+ }
295+ for j in 0 .. m {
296+ if ! vis [j ] {
297+ vis [j ] = true ;
298+ dfs (i + 1 , s + g [i ][j ], m , g , vis , ans );
299+ vis [j ] = false ;
300+ }
301+ }
302+ }
303+
304+ dfs (0 , 0 , m , & g , & mut vis , & mut ans );
305+ ans
306+ }
307+ }
308+ ```
309+
310+ #### JavaScript
311+
312+ ``` js
313+ /**
314+ * @param {number[][]} students
315+ * @param {number[][]} mentors
316+ * @return {number}
317+ */
318+ var maxCompatibilitySum = function (students , mentors ) {
319+ let ans = 0 ;
320+ const m = students .length ;
321+ const vis = Array (m).fill (false );
322+ const g = Array .from ({ length: m }, () => Array (m).fill (0 ));
323+
324+ for (let i = 0 ; i < m; ++ i) {
325+ for (let j = 0 ; j < m; ++ j) {
326+ for (let k = 0 ; k < students[i].length ; ++ k) {
327+ if (students[i][k] === mentors[j][k]) {
328+ g[i][j]++ ;
329+ }
330+ }
331+ }
332+ }
333+
334+ const dfs = function (i , s ) {
335+ if (i >= m) {
336+ ans = Math .max (ans, s);
337+ return ;
338+ }
339+ for (let j = 0 ; j < m; ++ j) {
340+ if (! vis[j]) {
341+ vis[j] = true ;
342+ dfs (i + 1 , s + g[i][j]);
343+ vis[j] = false ;
344+ }
345+ }
346+ };
347+
348+ dfs (0 , 0 );
349+ return ans;
350+ };
351+ ```
352+
225353<!-- tabs: end -->
226354
227355<!-- solution: end -->
0 commit comments