N-person n-square event assignment method based on main and subarrays

Abstract

The invention provides a method for assigning n persons and n square events based on a main sub-array, which comprises the following steps of: starting from an initial assignment matrix # imgabs0 #, circularly operating a FullyGoupRowMinElement Domain Extend (k) function, a FullGoupChannel (k) function, a GoupExtend Look (k) function, an absentGoupExtend Channel (k, r) function and an absentGoupExtend Look (k, r) function, performing same-solution transformation on the assignment matrix to obtain a local optimal assignment solution sequence sk (k = 1, 2, 3,..., n) of k persons and kn events (each person has n events) on a k * kn type main sub-array Ak * kn, gradually increasing a k The local optimal assignment solution of k persons and kn events (each person has n events) is the global optimal assignment solution of n persons and n2 events (each person has n events) of the initial assignment matrix. The method can solve the problem of'n-person n2 event assignment ', has solution convergence and low calculation complexity and difficulty, is a polynomial algorithm, and has the calculation complexity of o (n5).

Description

Technical Field

[0001] The invention relates to the field of allocation technology, and in particular to an assignment method based on a main sub-array of n persons and n squares. Background Art

[0002] Nowadays, in fields such as logistics or robotics, we often encounter the problem of assigning multiple tasks to multiple robots or personnel. This makes the task allocation more reasonable and reliable, especially in the current situation where each person needs to do multiple things, which requires more reasonable assignment.

[0003] For the allocation assignment problem, the existing mature theories and algorithm technologies are limited to "n-person n-job assignment" and "n-person 2n-job assignment". From the perspective of the generation and development of assignment problem algorithms, the Hungarian method is the earliest "n-person n-job assignment" algorithm, which was proposed by American operations researcher Kuhn in 1955, but the algorithm does not have the solution convergence; in 1992, Zhou Liangze proposed the "cutting high elimination method to solve the assignment problem" in the Journal of Systems Engineering, and in 1994, Zhang Liang proposed the "new algorithm for the assignment problem" to become the Zhou Liangze-Zhang Liang algorithm to improve the "n-person n-job assignment" algorithm, which has the solution convergence; in 2003, Zhou Liangze proposed the theory and method for solving the n-person 2n-job assignment problem in Military Operations Research and Systems Engineering; in 2007, Zhou Liangze proposed Solving Assignment Problem for n persons and 2n jobs using the Method of mainsubmatrix in Conference on System Science, Management Science & System Dynamics. The theory and method for solving the n-person 2n-task assignment problem and the principal sub-matrix algorithm all have convergent solutions.

[0004] As for "n people n 2 The task assignment problem is that n people should do n tasks. 2 The question is how to combine events and assign personnel to complete the tasks in the least costly way. The Hungarian method is an algorithm limited to assigning n people to n tasks. 2 Task assignment" problem, on the one hand, requires the matrix Convert to The computational complexity is o(n 6 ), the calculation is complicated and the difficulty increases. On the other hand, since the algorithm is solved in a tentative way during the solution process, there is no theoretical guarantee for the solution convergence, and the solution convergence is a necessary attribute of the algorithm. It is impossible to ensure that “n people n 2The problem of "assignment of tasks to n persons" has a solution; the Zhou Liangze-Zhang Liang'ang algorithm and the Zhou Liangze principal matrix algorithm are both convergent two-dimensional assignment algorithms, but in engineering they only implement the problems of "assignment of n persons to n tasks" and "assignment of n persons to 2n tasks". 2 The task assignment problem also requires the matrix Convert to It has the convergence of solution, but the computational complexity is also o(n 6 ).

[0005] For example, Chinese patent application No. 202011165291.1, published on May 13, 2022, discloses a task allocation method and a task allocation device. The control center can obtain task data and determine the task category of the task corresponding to the task data. Then, each subtask category corresponding to the task category can be queried, and for each subtask category, the subtask corresponding to the subtask category is generated according to the task data and the task configuration data corresponding to the subtask category. Furthermore, according to the subtasks corresponding to each subtask category, the pending tasks corresponding to the task data are generated. The control center can determine the handling equipment that matches the pending task as the target handling equipment, and determine at least one workstation that matches the pending task as at least one target workstation, assign the pending task to the target handling equipment, and for each target workstation, assign the subtasks that match the target workstation contained in the pending task to the target workstation, thereby improving work efficiency.

[0006] In the above-mentioned Chinese patent documents, the allocation of tasks is mainly based on task configuration data and task categories, and no improvement is considered in the allocation method. It is also impossible to achieve the allocation of n-person multi-events, so the allocation effect is low. Summary of the invention

[0007] The purpose of the present invention is to provide a method for assigning tasks based on n-person n-square tasks of a main sub-array, which can 2 The algorithm solves the "task assignment" problem with convergence and low computational complexity.

[0008] The present invention provides a method for assigning tasks based on n-person n-square tasks of a main sub-array, comprising the following steps:

[0009] S1 sets n and matrix The initial value of the matrix The initial value is n people doing n 2 The consumption corresponding to the event. Define k as the number of independent full row minimum tuples, r as the number of row minimum elements in the default row minimum tuple, set the initial values ​​k = 1, r = 1, and the preset coordinate array is x[i] = i, (1≤i≤n), y[j] = j, (1≤j≤n 2);definition

[0010] FullyGoupRowMinElementDomainExtend(k) function, FullGoupChange(k) function, GoupExtendLook(k) function, absentGoupExtendChange(k, r) function, absentGoupExtendLook(k, r) function;

[0011] S2 uses the Konig property to Perform the same transformation to obtain the new matrix when k = 1 and its subarray And make the subarray The above elements are equal;

[0012] S3 uses the FullyGoupRowMinElementDomainExtend(k) function on the subarray The minimum tuple E of the last k independent full rows k right Perform the same solution transformation to obtain the new and its subarray Make E k Still a subarray The k independent full-row minimum tuples on ;

[0013] S4 uses the FullGoupChange(k) function to calculate the minimum tuple E of k independent full rows. k right Perform the same solution transformation to obtain its submatrix Make the subarray There are k+1 row minimum tuples in , and each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains only one row minimum element;

[0014] S5 uses the GoupExtendLook(k) function to look at the subarray Perform the operation and find the k+1 independent row minimum tuple E in the form of coordinate calibration (k，1) , and each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains only one row minimum element;

[0015] S6 uses the absentGoupExtendChange(k, r) function to change the subarray The k+1 independent row minimum tuple E on (k，r) right Implement the same solution transformation to obtain a new Make its subarray There are k + 1 row minimum elements E in (k，r+1) , and each of the first k row minimum element groups contains n row minimum elements, and the (k + 1)-th row minimum element group contains exactly r + 1 row minimum elements;

[0016] S7 operates on the sub-matrix through the absentGoupExtendLook(k, r) function to specifically find k + 1 row minimum element groups E (k，r+1) , where each of the first k row minimum element groups contains n row minimum elements, and the (k + 1)-th row minimum element group contains r + 1 row minimum elements;

[0017] S8 compares the values of r and n - 1:

[0018] If r < n - 1, then r = r + 1, and go to step S6;

[0019] If r = n - 1, go to step 9.

[0020] S9 compares the values of k and n - 1:

[0021] If k < n - 1, then k = k + 1, and go to step S3;

[0022] If k = n - 1, then go to step S10.

[0023] S10 obtains the equivalent solution matrix of the matrix and marks the optimal combination solution of the assignment event.

[0024] With the above settings, by using the konig property to perform an equivalent transformation on the initial matrix to obtain a new and making the elements on its sub-matrix A 1×n equal, thus the 1-person n-event local optimal solution tuple C1 on the 1st order principal sub-matrix A 1×n can be obtained. Let k = 1, call the FullyGoupRowMinElementDomainExtend(k) function to perform an equivalent transformation on the sub-matrix A n×2n to obtain a new which can ensure that the 1-person n-event local optimal solution tuple C1 of its sub-matrix A 1×n is still the independent full row minimum element group of its corresponding row in the sub-matrix A 1×2n . Call the FullGoupChange(k) function to perform an equivalent transformation on the sub-matrix A of the new n×2n , then it can ensure that the sub-matrix A 2×2nThere are two independent row minimum tuples C(1,1) in A, where the first row minimum tuple contains n row minimum elements and the second row minimum tuple contains 1 row minimum element. 2×2n By calculating the elements of A, we can find the submatrix A in the form of coordinate positioning. 2×2n There are two independent row minimum tuples C(1,1), where the first row minimum tuple contains n row minimum elements, and the second row minimum tuple contains 1 row minimum element.

[0025] The first call to the absentGoupExtendChange(k, r) function (k=1, r=1) is Subarray A n×2n Top pair Implementing the same solution transformation can ensure that the sub-matrix A of the transformation result 2×2n There are two independent row minimum tuples C(1, 2), where the first row minimum tuple contains n row minimum elements and the second row minimum tuple contains 2 row minimum elements.

[0026] By using the absentGoupExtendLook(k, r) function in subarray A 2×2n By performing operations on sub-matrix A, we can ensure that 2×2n Here, the two independent row minimum tuples C(1, 2) are found specifically in the form of coordinate positioning, where the first row minimum tuple contains n row minimum elements, and the second row minimum tuple contains 2 row minimum elements.

[0027] Generally, let sub-matrix A 2×2n Here, we find these two independent row minimum tuples C(1, r) in the form of coordinate positioning, where the first row minimum tuple contains n row minimum elements, and the second row minimum tuple contains r row minimum elements (1≤r<n). Call absentGoupExtendChange(k, r) function in subarray A n×2n Top pair Perform the same solution transformation and obtain the new By running the absentGoupExtendLook(k, r) function, it can be ensured that in its subarray A 2×2nSpecifically find these 2 independent row minimum tuples C(1, r + 1) in the form of coordinate positioning, where the first row minimum tuple contains n row minima, and the second row minimum tuple contains r + 1 row minima. Perform the discriminant operation r < n - 1? If "r < n - 1" is true, perform the increment operation: r = r + 1. Continue to loop and call the absentGoupExtendChange(k, r) function and the absentGoupExtendLook(k, r) function until "r < n - 1" is false (i.e., r = n - 1). At this time, it can be ensured that in the sub-matrix A 2×2n Specifically find 2 independent row minimum tuples C(1, n) in it. Both of these 2 independent row minimum tuples contain n row minima. Thus, find the 2nd order principal sub-matrix A 2×2n The 2-person 2n-matter local optimal solution tuple C2 on it.

[0028] The above is based on The sub-matrix A 1×n There is already a local optimal solution tuple C1 as the starting point. Through 1 call of the FullGoupChange(k) function and the GoupExtendLook(k) function, and then through n - 1 loop calls of the absentGoupExtendChange(k, r) function and the absentGoupExtendLook(k, r) function, a new In its sub-matrix A 2×2n Find the sub-matrix A in the form of coordinate positioning 2×2n The process of the 2-person 2n-matter local solution tuple C2.

[0029] Generally, assume that for the initial matrix After the above-mentioned equivalent transformation function and search function calls, k (1 ≤ k < n - 1) independent full row minimum tuples Ck have been found on the kth order principal sub-matrix A of the new equivalent matrix. Similar to the solution process from "1-person n-matter local solution tuple C1" to "2-person 2n-matter local solution tuple C2", that is, through 1 call of the FullGoupChange(k) function and 1 call of the GoupExtendLook(k) function, and then through n - 1 loop calls of the absentGoupExtendChange(k, r) function and the absentGoupExtendLook(k, r) function, a new k×kn On its (k + 1)th order principal sub-matrix A It is certain to ensure that in the form of coordinate positioning, the principal sub-matrix A (k+1)×(k+1)n is found (k+1)×(k+1)nThe (k + 1)-person (k + 1)n-event partial solution tuple C(k + 1). By performing a discriminant operation on "k < n - 1", as long as "k < n - 1" holds, then k = k + 1, and then step S3 is continued to be repeated until "k < n - 1" does not hold, that is, k = n - 1. At this time, n = k + 1, and step 9 is entered.

[0030] When k = n - 1, in the principal submatrix A (k+1)×(k+1)n The obtained (k + 1)-person (k + 1)n-event partial solution tuple C(k + 1) is exactly the n-person n 2 optimal solution tuple C(n) of.

[0031] From a global perspective, the entire solution process is divided into an outer loop and an inner loop. k is the outer loop variable, and r is the inner loop variable.

[0032] The iterative idea and iterative steps of this algorithm are clear. The algorithm complexity is o(n 5 ), the calculation method is simple and reliable, and it has solution convergence.

[0033] Furthermore, the programming algorithm and function implementation of the FullyGoupRowMinElementDomainExtend(k) function in step S1 are based on the following theorem (the theorem proof is omitted):

[0034] Theorem 1: Let be the k-order k × kn-type principal submatrix of the matrix with k independent full-row minimum element tuples on it, ({x[i]|1 ≤ i ≤ k} = {i|1 ≤ i ≤ k}, {y[j]|1 ≤ j ≤ kn} = {j|1 ≤ j ≤ kn}, 1 ≤ k < n), each group contains n row minimum elements. Let

[0035]

[0036] Adding a constant c to each element in the j-th column (kn + 1 ≤ j ≤ (k + 1)n) of the matrix to obtain a new matrix Then is the k-order k × (k + 1)n-type principal submatrix of the new matrix with k independent full-row minimum element tuples on it, where

[0037] {x[i]|1 ≤ i ≤ k} = |i|1 ≤ i ≤ k}, {y[j]|1 ≤ j ≤ kn} = |j|1 ≤ i ≤ kn}, k < n,

[0038] {x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤i≤(k+1)n}.

[0039] The function FullyGoupRowMinElementDomainExtend(k) in step S1 is defined based on Theorem 1.

[0040] With the above settings, after running FullyGoupRowMinElementDomainExtend(k), the subarray The k independent full-row minimum tuples on must be submatrices The k independent full-row minimal tuples on .

[0041] Furthermore, the programming algorithm and functional implementation of the FullGoupChange(k) function in step S1 are based on the following theorem (theorem proof is omitted):

[0042] Theorem 2: Assume is its k×(k+1)n type main sub-matrix k independent full-row minimum tuples on A (1≤k<n), {x[i]|1≤i≤k}={i|1≤i≤k}{y[j]|1≤j≤kn}={j|1≤j≤kn}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}; (k) , A (k-1) , Λ, A (2) , A (1) , A (0) A (k) is the matrix sequence obtained by gradually transforming the initial matrix, A (p) To A (p-1) The transformation rule is: (p) Add a constant c to each element in the column where the smallest element of the x[p]th group of rows is located p And get A (p-1) , (1≤p≤k), c p And x[p] is determined to satisfy the following conditions:

[0043]

[0044] (h∈{j|pn+1≤j≤(k+1)n}). .

[0045] Then, in the final matrix The k×(k+1)n main sub-matrix Its elements have the following properties:

[0046] (1) It's the main array k independent full-row minimum tuples on (each group contains n row minimum elements), ({x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn});

[0047] (2)

[0048] ({y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}).

[0049] The function FullGoupChange(k) in step S1 is defined based on Theorem 1.

[0050] Furthermore, the programming algorithm and functional implementation of the GoupExtendLook(k) function in step S1 are based on the following theorem (theorem proof is omitted):

[0051] Theorem 3 Let the submatrix The elements in have the following properties:

[0052] (1) It is a subarray k independent full-row minimum tuples in (k ≥ 1, {x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}{y[j]|1≤j≤(k+1)n}=(j|1≤j≤(k+1)n})

[0053] (2)

[0054] Then in the subarray We can definitely find k+1 independent row minimum tuples in the form of coordinate positioning:

[0055] and

[0056] Each of the first k groups contains n row minimum elements, and the k+1th group contains 1 row minimum element. Among them, {x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, {x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}=(j|1≤j≤(k+1)n}.

[0057] (The proof of Theorem 3 will provide a method for finding the minimum tuple of these k+1 independent rows, the proof is omitted).

[0058] The definition of function GoupExtendLook(k) in step S1 is written based on Theorem 3.

[0059] The above settings can ensure that the (k+1)×(k+1)n main sub-array is in the form of coordinate calibration through the GoupExtendLook(k) function operation. Find k full-row minimum tuples in the first k rows of , and find 1 row minimum tuple in the k+1th row, which together constitute k+1 independent row minimum tuples.

[0060] Furthermore, the programming algorithm and functional implementation of the absentGoupExtendChange(k, r) function in step S1 are based on the following theorem (theorem proof is omitted):

[0061] Theorem 4: Assume and is its (k+1)×(k+1)n type main sub-matrix There are k+1 independent row minimum tuples in A, where each of the first k groups contains n row minimum elements, and the k+1th group contains r row minimum elements (1≤r<n); ({x[i]|1≤j≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, 1≤k<n, {x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}). (k +1) , A (k) , Λ, A (2) , A (1) , A (0) A (k+1) is the matrix sequence obtained by gradually transforming the initial matrix. The process of obtaining the matrix sequence is:

[0062] (1) In A (p) Add a constant cp (1≤p≤k+1, where c p and x[t] is determined so that it satisfies

[0063]

[0064] (2) If x[p]≠x[t], (in this case p>1), swap the row coordinate values ​​and column coordinate values ​​of the two groups of elements of the x[p] group of row minimum elements and the x[t] group of row minimum elements, and then swap the row coordinate values ​​and column coordinate values ​​of the two groups of elements of the x[p] group of row minimum elements and the x[p-1] group of row minimum elements, and obtain A (p-1) , perform the operation p--subtracting 1 from p, return to step (1), and then calculate A (p-2) ;

[0065] (3) If x[p] = x[t] and p>1, swap the row coordinates and column coordinates of the two groups of elements of the x[p] group and the x[t] group. Then we get A. (p-1) , call the FullGoupChange(k) function to obtain the remaining subsequence A (p-2) ,A (p-3) ,…,A (2) ,A (1) ,A (0) ;

[0066] (4) If x[p] = x[t] and p = 1, then we get A (p-1) , and you get A (0) , then, so with A (k+1) The matrix sequence A is obtained by gradually transforming the initial matrix (k+1) ,A (k) ,…,A (2) ,A (1) ,A (0) , then the final matrix The (k+1)×(k+1)n type principal matrix The elements have the following properties:

[0067] 1) and It is a (k+1)×(k+1)n type main sub-matrix

[0068] k+1 independent row minimum tuples (1≤k <n),

[0069] ({x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤i≤(k+1)n}), where the first k

[0070] Each group contains n row minimum elements, and the k+1th group contains r row minimum elements (1≤r <n)。

[0071] 2)

[0072] 3)

[0073] The definition of the function absentGoupExtendChange(k, r) in step S1 is written based on Theorem 4.

[0074] The above settings can ensure that the final matrix is The principal submatrix of size \((k + 1)\times(k + 1)n\) contains \(k + 1\) row minimum tuples, where each of the first \(k\) row minimum tuples contains \(n\) row minimum elements, and the \((k + 1)\)-th row minimum tuple contains \(r + 1\) row minimum elements.

[0075] Furthermore, the programming algorithm and function implementation of the absentGoupExtendLook(k, r) function in step S1 are based on the following theorem (the theorem proof is omitted):

[0076] Theorem 5 Let and be \(k + 1\) independent row minimum tuples in the \((k + 1)\times(k + 1)n\) type submatrix (\(1\leq k\lt n\)), (\(\{x[i]\mid1\leq i\leq k\}=\{i\mid1\leq i\leq k\}\), \(\{y[j]\mid1\leq j\leq kn\}=\{j\mid1\leq i\leq kn\}\)), (\(\{x[i]\mid1\leq i\leq k + 1\}=\{i\mid1\leq i\leq k + 1\}\), \(\{y[j]\mid1\leq j\leq(k + 1)n\}=\{j\mid1\leq j\leq(k + 1)n\}\)), where each of the first \(k\) groups contains \(n\) row minimum elements, the \((k + 1)\)-th group contains \(r\) row minimum elements (\(1\leq r\lt n\)) and

[0077] (1)

[0078] (2) Then in the \((k + 1)\times(k + 1)n\) type principal submatrix one can surely find \(k + 1\) independent row minimum tuples:[[]]

[0079] and

[0080] where \(\{x[i]\mid1\leq i\leq k\}=\{i\mid1\leq i\leq k\}\), \(\{y[j]\mid1\leq j\leq(k + 1)n\}=\{j\mid1\leq j\leq(k + 1)n\}\), \(x[k + 1]=k + 1\), where each of the first \(k\) groups contains \(n\) row minimum elements, and the \((k + 1)\)-th group contains \(r + 1\) row minimum elements. (The method of finding these \(k + 1\) independent row minimum tuples will be given in the proof process of Theorem 5, the proof is omitted).

[0081] The absentGoupExtendLook(k, r) function in step S1 is defined according to Theorem 5.

[0082] With the above settings, through the operation of the absentGoupExtendLook(k, r) function, the submatrix can be obtained in the form of coordinate calibration There are k+1 row minimum tuples, among which each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains r+1 row minimum elements.

[0083] Instruction Manual

[0084] Figure 1 It is a solution flow chart of the present invention. DETAILED DESCRIPTION

[0085] The present invention is further described in detail below in conjunction with the "solution flow chart" and specific implementation methods in the accompanying drawings of the specification.

[0086] A method for assigning tasks based on n-person n-square tasks in a master matrix, such as Figure 1 As shown, the specific steps are as follows:

[0087] S1 sets n and matrix The initial value of the matrix The initial value is n people doing n 2 The consumption corresponding to the event. In this embodiment, the consumption corresponding to the event can be the corresponding figures such as the time consumption or power consumption of the event. k is defined as the number of independent full-row minimum tuples, k=1, r is the number of row minimum tuples in the default row minimum tuple, r=1, and the preset coordinate array is

[0088] x[i]=i,(1≤i≤n),y[j]=j,(1≤j≤n 2 )

[0089] define FullyGoupRowMinElementDomainExtend(k);

[0090] FullGoupChange(k) function;

[0091] GoupExtendLook(k) function;

[0092] absentGoupExtendChange(k, r) function; absentGoupExtendLook(k, r)

[0093] function.

[0094] In this embodiment, n=3, the coordinate array is initialized as x[i]=i, (1≤i≤3), y[j]=j, (1≤j≤9), and the initial matrix is ​​as follows:

[0095]

[0096] S2 uses the Konig property to calculate the matrix A 3×9 Perform the same transformation to get the matrix and making its sub - matrix have the same elements (all 20, as indicated by the * sign), the matrix is represented as follows:

[0097]

[0098] It is obtained by adding the constant 14 to each element in the second column and adding the constant 16 to each element in the third column of the initial matrix A shown in formula (1) of step (1). (The mathematical processing and sub - algorithm for transforming from matrix (1) to matrix (2) are very simple and are omitted here). 3×9

[0099] Now the values on the sub - matrix are equal, and they are These 3 elements (20, 20, 20) are the optimal solution of 1 person and 3 events determined by the sub - matrix

[0100] S3 calls the function FullyGoupRowMinElementDomainExtend(k), making the 1 independent row - minimum tuple on the sub - matrix in formula (2) This is also the row - minimum tuple on the sub - matrix

[0101] The definition and algorithm of the function FullyGoupRowMinElementDomainExtend(k) are as described in Theorem 1.

[0102] Theorem 1: Let be the k - order k×kn - type principal sub - matrix of the matrix with k independent full - row minimum tuples on it, ({x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, 1≤k < n), each group containing n row - minimum elements. Let

[0103]

[0104] Adding the constant c to each element in each j - th column (kn + 1≤j≤(k + 1)n) of the matrix to obtain the new matrix Then is the k - order k×(k + 1)n - type principal sub - matrix of the new matrix with k independent full - row minimum tuples on it, where

[0105] {x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, k < n,​​​

[0106] {x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}.

[0107] According to Theorem 1, calculate c k As follows (k=1 at this time):

[0108]

[0109] have have have

[0110] Now x[1]=1,y[j]=j(1≤j≤6), we have

[0111]

[0112] c1=min{11, 12, 13}-20=-9<0

[0113] c=-c1=9

[0114] According to the algorithm in Theorem 1, in the matrix shown in (2) Add the constant 9 to each element of each j-th column (kn+1≤j≤(k+1)n, that is, 4≤j≤6) of as follows:

[0115]

[0116] It is shown in formula (2) It is obtained by adding the constant 9 to the elements in the 4th, 5th, and 6th columns of . Now, formula (3) shows Son of the Array The smallest independent full-row tuple on

[0117] (a 11 ,a 12 ,a 13 )=(20,20,20)

[0118] Already a subarray The smallest tuple of 1 independent full rows on .

[0119] The FullyGoupRowMinElementDomainExtend(k) function call in step S3 is a conditional preparation for the FullGoupChange(k) function call in step S4.

[0120] S4 calls the function FullGoupChange(k) to the matrix shown in formula (3) Make a transformation

[0121] The definition and algorithm of the function FullGoupChange(k) are as described in Theorem 2.

[0122] Theorem 2: Assume is its k×(k+1)n type main sub-matrix k independent full-row minimum tuples on <n),{x[i]|1≤i≤k}={i|1≤i≤k}{y[j]|1≤j≤kn}={j|1≤j≤kn},{y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n};A (k) ,A (k-1) ,…,A (2) ,A (1) ,A (0) A (k) is the matrix sequence obtained by gradually transforming the initial matrix, A (p) To A (p -1) The transformation rule is: (p) Add a constant c to each element in the column where the smallest element of the x[p]th group of rows is located p And get A (p-1) , (1≤p≤k), c p And x[p] is determined to satisfy the following conditions:

[0123]

[0124] Then, in the final matrix The k×(k+1)n main sub-matrix Its elements have the following properties:

[0125] (1) It's the main array k independent full-row minimum tuples on (each group contains n row minimum elements), ({x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn});

[0126] (2) According to Theorem 2, we now need to transform A (1) Transform to A (0) , (at this time, k = 1, n = 3, p = 1). p The value is calculated as follows:

[0127]

[0128] Right now

[0129]

[0130] c1=min{min{20,21,22}-20}

[0131] c1=min{20-20}=0

[0132] And {x[i]|1≤i≤k}={i|1≤i≤k}, that is, {x[i]|1≤i≤1}={i|1≤i≤1}, {x[1]}={1}, that is, x[1]=1. Now p=1. A (p) To A (p-1) The transformation rule is: (p) Add a constant c to each element in the column where the smallest element of the x[p]th group of rows is located p . That is A (1) To A (0) The transformation rule is: (1) Add a constant c1 to each element in the column where the minimum element of the x[1]th row is located, that is, in A (1) Add a constant 0 to each element in the column where the minimum element of the first group of rows is located. Therefore, A (1) It's A (0) . A (0) As shown below:

[0133]

[0134] S5 calls the GoupExtendLook(k) function to find the matrix A shown in formula (4) (0) In the sub-array, the coordinates are located Specifically, we find two groups of independent row minimum elements (the first group contains three row minimum elements. The second group contains only one row minimum element)

[0135] The GoupExtendLook(k) function is defined according to the following Theorem 3:

[0136] Theorem 3 Let the submatrix The elements in have the following properties:

[0137] (1) It is a subarray k independent full-row minimum tuples in (k ≥ 1, {x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n});

[0138] (2)

[0139] Then in the subarray We can definitely find k+1 independent row minimum tuples:

[0140] and

[0141] ({x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}) where each of the first k groups contains n row minimum elements, and the k+1th group contains 1 row minimum element.

[0142] Note: The specific search method is given in the proof of the theorem (proof omitted).

[0143] In the matrix A shown in formula (4) (0) The above is calculated by the function GoupExtendLook(1) and the following result is obtained: Specifically, two groups of independent row minimum elements were found (the first group contains three row minimum elements. The second group contains only one row minimum element). The calibration results are as follows (indicated by *):

[0144]

[0145] In fact and It is a subarray There are k+1=2 independent row minimum tuples on the network, where each of the first k (k=1) groups contains n (n=3) row minimum elements, and the k+1 (k+1=2) group contains 1 row minimum element. Their coordinates satisfy:

[0146] ({x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}).

[0147] S6 calls absentGoupExtendChange(k, r) function on the matrix shown in formula (5)

[0148] The absentGoupExtendChange(k, r) function is defined as follows:

[0149] Theorem 4: Assume and is its (k+1)×(k+1)n type main sub-matrix k+1 independent row minimum tuples in the , where each of the first k groups contains n row minimum elements, and the k+1th group contains r row minimum elements (1≤r <n);({x[i]|1≤i≤k}={i|1≤i≤k},{y[j]|1≤j≤kn}={j|1≤j≤kn},1≤k<n,{x[i]|1≤i≤k+1}={i|1≤i≤k+1},{y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n})。A (k+1) ,A (k) ,…,A (2) ,A (1) ,A (0) A (k+1) is the matrix sequence obtained by gradually transforming the initial matrix. The process of obtaining the matrix sequence is:

[0150] (1) In A (p) Add a constant c to each element in the column where the smallest element of the x[t]th group of rows is located p (1≤p≤k+1), where c p and x[t] is determined so that it satisfies

[0151]

[0152] (2) If x[p]≠x[t], (in this case p>1), swap the row coordinates and column coordinates of the two groups of elements of the x[p] group of minimum elements and the x[t] group of minimum elements, and then swap the row coordinates and column coordinates of the two groups of elements of the x[p] group of minimum elements and the x[p-1] group of minimum elements, and get A (p-1) , perform the operation p--subtracting 1 from p, return to step (1), and then calculate A (p-2) ;

[0153] (3) If x[p] = x[t] and p>1, swap the row coordinates and column coordinates of the two groups of elements of the x[p] group and the x[t] group. Then we get A. (p-1) , call the FullGoupChange(k) function to obtain the remaining subsequence A (p -2) ,A (p-3) ,…,A (2) ,A (1) ,A (0) ;

[0154] (4) If x[p] = x[t] and p = 1, then we get A (p-1) , and you get A (0) , then, so with A (k+1) The matrix sequence A is obtained by gradually transforming the initial matrix (k+1) ,A (k) ,…,A(2) ,A (1) ,A (0) , then the final matrix The (k+1)×(k+1)n type principal matrix The elements have the following properties:

[0155] 1) and It is a (k+1)×(k+1)n type main sub-matrix k+1 independent row minimum tuples (1≤k <n),

[0156] ({x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤i≤(k+1)n}), where

[0157] Each of the first k groups contains n row minimum elements, and the k+1th group contains r row minimum elements (1≤r <n)。

[0158] 2)

[0159]

[0160] The matrix shown in formula (5) is Immediately

[0161]

[0162] Now A (2) middle and It is a subarray There are k+1=2 independent row minimum tuples, of which each of the first k (k=1) groups contains n (n=3) row minimum elements, and the k+1 (k+1=2) group contains 1 row minimum element. Their coordinates satisfy:

[0163] ({x[i]|1≤i≤k+1}={i|1≤i≤k+1}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}).

[0164] According to the operation rules of Theorem 4, in step 1, A (2) Transform to A (1) The result of the operation is A shown in formula (6) (2) Add 1 to each element in the 2nd, 3rd, and 4th columns to get A. (1) as follows:

[0165]

[0166] Step 2: Substitute (7) into A (1)Transform to A (0) , and the operation result is on A (1) add 8 to each element in the first column of A to get A (0) as follows:

[0167]

[0168] (8) The matrix is the result of calling the absentGoupExtendChange(1, 1) function for the matrix in (6).

[0169] S7 calls the absentGoupExtendChange(k, r) function for the matrix shown in (8)

[0170] The definition of the absentGoupExtendLook(k, r) function is as follows:

[0171] Theorem 5 Let and be k + 1 independent row minimum tuples in the (k + 1)×(k + 1)n - type sub - matrix (1 ≤ k < n), ({x[i]|1 ≤ i ≤ k} = {i|1 ≤ i ≤ k}, {y[j]|1 ≤ j ≤ kn} = {j|1 ≤ i ≤ kn}), ({x[i]|1 ≤ i ≤ k + 1} = {i|1 ≤ i ≤ k + 1}, {y[j]|1 ≤ j ≤ (k + 1)n} = {j|1 ≤ j ≤ (k + 1)n}), where each of the first k groups contains n row minimum elements, the (k + 1) - th group contains r row minimum elements (1 ≤ r < n) and

[0172] (1)

[0173] (2) Then in the (k + 1)×(k + 1)n - type principal sub - matrix k + 1 independent row minimum tuples can surely be found:

[0174] and

[0175] where {x[i]|1 ≤ i ≤ k} = {i|1 ≤ i ≤ k}, {y[j]|1 ≤ j ≤ (k + 1)n} = {j|1 ≤ j ≤ (k + 1)n}, x[k + 1] = k + 1, each of the first k groups contains n row minimum elements, and the (k + 1) - th group contains r + 1 row minimum elements.

[0176] After running the absentGoupExtendChange(1, 1) function for the matrix A shown in (8) (0) the following result is obtained:

[0177]

[0178] Now, for the matrix A shown in formula (9) (0) its sub-matrices have been marked in the form of coordinate positioning (see * symbol).

[0179]

[0180] Among them, there are 2 (k + 1 = 2) independent row minimum tuples. Among the first 1 (k = 1) row minimum tuples, each row minimum tuple contains 3 (n = 3) row minimum elements, and the (k + 1 = 2)th row minimum tuple contains r + 1 = 2 row minimum elements.

[0181] S8 compares the values of r and n - 1:

[0182] If r < n - 1, then r = r + 1, and go to step S6;

[0183] If r = n - 1, go to step 9.

[0184] Now r = 1 < 2 = n - 1, perform the operation r = r + 1, and go to step S6;

[0185] Enter step S6 for the second time, call the absentGoupExtendChange(k, r) function to perform a transformation on the matrix shown in formula (9). Regard the matrix shown in formula (9) as the new A (2) , that is, record

[0186]

[0187] Now k = 1, r = 2. For the matrix A shown in formula (10) (2) Run the absentGoupExtendChange(1, 2) function. In the first step, transform A (2) to A (1) Get the result:

[0188]

[0189] It is the result of adding the constant 1 to each element in the 2nd, 3rd, and 4th columns of the matrix shown in formula (10).

[0190] In the second step, transform A (1) to A (0) Get the result:

[0191]

[0192] It is the result of adding the constant 3 to each element in the 1st and 5th columns of the matrix shown in formula (11).

[0193] Enter step S7 for the second time, and call the function for the matrix shown in formula (12)

[0194] absentGoupExtendLook(k, r)

[0195] That is, for the matrix shown in formula (12) Run the function absentGoupExtendLook(1, 2), and the following results are obtained:

[0196]

[0197] Now, for the matrix A shown in formula (13) (0) Its submatrices have been marked in the form of coordinate positioning (see the * symbol)

[0198]

[0199] Among them, there are 2 (k + 1 = 2) independent row minimum tuples. Among the first 1 (k = 1) row minimum tuples, each row minimum tuple contains 3 (n = 3) row minimums, and the (k + 1 = 2)th row minimum tuple contains r + 1 = 3 row minimums.

[0200] The matrix shown in formula (13) Among its submatrices 2 independent row minimum tuples have been marked in the form of coordinate positioning (see the * symbol) They are the principal submatrices of the matrix shown in formula (13) The local optimal solutions of 2 people and 2n events (n = 3) on it.

[0201] S8 Compare the values of r and n - 1: If r < n - 1, then r = r + 1, and go to step S6;

[0202] If r = n - 1, go to step 9.

[0203] Now r = 2 = 3 - 1 = n - 1, so go to step S9;

[0204] S9 Compare the values of k and n - 1: If k < n - 1, then k = k + 1, and go to step S3;

[0205] If k = n - 1, then go to step S10.

[0206] Now k = 1 < 2 = 3 - 1 = n - 1, that is, k < n - 1, so the execution result of step S9 is: perform the operation k = k + 1 = 2, and transfer to step S3;

[0207] The execution result of S9 is k = 2, and according to its algorithm, transfer to step S3.

[0208] Repeat from step S3 until the matrix shown in formula (13) The process up to this point, that is, repeating the process from S3 of p14 to S8 of p22, yields a new as follows:

[0209]

[0210] During the process of repeating from S3 of p14 to S8 of p22, the final stage is to execute step S8 of p22. The result of executing this step S8 is: r = 2 = 3 - 1 = n - 1, and then enter step S9.

[0211] S9 compares the values of k and n - 1: If k < n - 1, then k = k + 1, and enter step S3;

[0212] If k = n - 1, then enter step S10.

[0213] At this time, k = 2 = 3 - 1 = n - 1, and the execution result of step S9 is to enter step S10.

[0214] S10 obtains the equivalent solution matrix of the initial matrix and marks the optimal combination solution of the assignment event. The solution is completed.

[0215] The initial matrix is as follows:

[0216]

[0217] The equivalent solution matrix is as follows:

[0218]

[0219] All the transformations experienced from the initial matrix shown in (1) to the matrix shown in (15') are equivalent transformations of the n-person n 2 task assignment matrix. That is, the initial matrix A shown in (1') 3×9 and the matrix shown in (15') Their solution tuples are corresponding.

[0220] The matrix shown in (15') indicates that the first person does 3 things corresponding to the consumption of 3 * 23, the second person does 3 things corresponding to the consumption of 3 * 27, and the third person does 3 things corresponding to the consumption of 3 * 30. This is the optimal assignment plan for 3 people and 9 things (3 things per person).

[0221] The solution process is summarized as follows:

[0222] 【1】This "specific implementation manner" starts from the beginning and goes through two steps, S1 and S2 (p13), to obtain the 1-person 3-task local optimal solution 1×3 on the principal submatrix A

[0223] 【2】Starting from step S3 (p14), and entering S8 for the second time at p22, we obtain the matrix shown in formula (13) The main array Local optimal solution for 2 people and 6 things on

[0224] [3] Repeat the solution process [2], that is, repeat the 1×n main matrix A 1×3 The local optimal solution of 1 person n tasks on the 2×2n main matrix A is extended to 2×2n The process of solving the local optimal solution of 2 people and 2n tasks on the 2-person 2n task is to obtain the main matrix shown in formula (15) The local optimal solution of 3 people and 9 things on This local optimal solution is exactly the matrix The global optimal solution of .

Claims

1. A method for assigning tasks based on n-person n-square tasks in a master matrix, characterized by: It includes the following steps: S1 sets n and matrix The initial value of the matrix The initial value is n people doing n 2 The consumption corresponding to the event, define k as the number of independent full row minimum tuples, r as the number of row minimum elements in the default row minimum tuple, set the initial value k = 1, r = 1, and the preset coordinate array is x[i] = i, (1≤i≤n), y[j] = j, (1≤j≤n 2 );definition FullyGoupRowMinElementDomainExtend(k) function, FullGoupChange(k) function, GoupExtendLook(k) function, absentGoupExtendChange(k, r) function, absentGoupExtendLook(k, r) function; S2 uses the Konig property to Perform the same transformation to obtain the new matrix when k = 1 and its subarray And make the subarray The above elements are equal; S3 uses the FullyGoupRowMinElementDomainExtend(k) function on the subarray The minimum tuple E of the last k independent full rows k right The same solution transformation is obtained to obtain a new and its subarray Make E k Still a subarray The above are k independent full-row minimum tuples; S4 uses the FullGoupChange(k) function to calculate the minimum tuple E of k independent full rows. k right Perform the same solution transformation to obtain its submatrix Make the subarray There are k+1 row minimum tuples in , and each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains only one row minimum element; S5 uses the GoupExtendLook(k) function to look at the subarray Perform operations and obtain k+1 independent row minimum tuples E by coordinate positioning (k，1) , and each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains only one row minimum element; S6 uses the absentGoupExtendChange(k, r) function to change the subarray The k+1 independent row minimum tuple E on (k，1) right Implement the same solution transformation to obtain a new Make its subarray There are k+1 minimum row tuples E in (k，r) , and each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains and only contains r+1 row minimum elements; S7 uses the absentGoupExtendLook(k, r) function to look at the subarray Perform calculations to find the k+1 minimum row tuple E by coordinate positioning (k，r) , where each of the first k row minimum tuples contains n row minimum elements, and the k+1th row minimum tuple contains r+1 row minimum elements; S8 Compare the value of r with n - 1: If r < n - 1, then r = r + 1, and go to step S6; If r = n - 1, then go to step 9; S9 Compare the value of k with n - 1: If k < n - 1, then k = k + 1, and go to step S3; If k = n - 1, then go to step S10; S10 gives the matrix The isomorphic matrix And mark the optimal combination solution of the assigned events.

2. The method for assigning tasks based on n-person n-square tasks in a master sub-array according to claim 1, characterized in that: The programming algorithm and function implementation of the FullyGoupRowMinElementDomainExtend(k) function in step S1 are based on the following theorem: Theorem 1: Assume is a matrix The k-order k×kn type principal submatrix There are k independent full-row minimum tuples on ({x[i]|1≤i≤k}=|i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, 1≤k<n), each containing n row minimum elements, let In the matrix Add the constant c to each element of each j-th column (kn+1≤j≤(k+1)n) to obtain a new matrix but is the new matrix The k-order k×(k+1)n-type principal submatrix The k independent full-row minimum tuples on {x[i]|1≤i≤k} = |i|1≤i≤k}, {y[j]|1≤j≤kn} = {j|1≤i≤kn}, k < n, {x[i]|1≤i≤k + 1} = {i|1≤i≤k + 1}, y[j]|1≤j≤(k + 1)n} = {j|1≤i≤(k + 1)n} 3. The method for assigning tasks based on n-person n-square tasks in a master sub-array according to claim 1, characterized in that: The programming algorithm and function implementation of the FullGoupChange(k) function in step S1 are based on the following theorem: Theorem 2: Assume is its k×(k+1)n type main sub-matrix k independent full-row minimum tuples on <n),{x[i]|1≤i≤k}={i|1≤i≤k},{y[j]|1≤j≤kn}={j|1≤j≤kn},{y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n};A (k) , A (k-1) , Λ, A (2) , A (1) , A (0) A (k) is the matrix sequence obtained by gradually transforming the initial matrix, A (p) To A (p-1) The transformation rule is: (p) Add a constant c to each element in the column where the smallest element of the x[p]th group of rows is located p And get A (p-1) , (1≤p≤k), c p And x[p] is determined to satisfy the following conditions: (h ∈ {j|pn + 1 ≤ j ≤ (k + 1)n}); Then, in the final matrix The k×(k+1)n main sub-matrix Its elements have the following properties: (1) It's the main array k independent full-row minimum tuples on the , each containing n row minimum elements, ({x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}); (2) The FullGoupChange(k) function written according to Theorem 2 in programming is the definition of this function.

4. The method for assigning tasks based on n-person n-square tasks in a master matrix according to claim 1, characterized in that: The programming algorithm and functional implementation of the GoupExtendLook(k) function in step S1 are based on the following theorem: Theorem 3: Let the subarray The elements in have the following properties: (1) It is a subarray k independent full-row minimum tuples in (k ≥ 1, {x[i]|1≤i≤k}={i|1≤i≤k}, {y[j]|1≤j≤kn}={j|1≤j≤kn}, {y[j]|1≤j≤(k+1)n}={j|1≤j≤(k+1)n}); (2) Then in the subarray We can definitely find k+1 independent row minimum tuples: and Among them, {x[i]|1≤i≤k + 1} = {i|1≤i≤k + 1}, {y[j]|1≤j≤(k + 1)n} = {j|1≤j≤(k + 1)n}, each of the first k groups contains n row minimum elements, and the (k + 1)-th group contains 1 row minimum element; The FullGoupChange(k) function written according to Theorem 3 in programming is the definition of this function.

5. The method for assigning tasks based on n-person n-square tasks in a master-sub-matrix according to claim 1, characterized in that: The programming algorithm and function implementation of the absentGoupExtendChange(k, r) function in step S1 are based on the following theorem: Theorem 4: Let and be k + 1 independent row minimum tuples in its (k + 1)×(k + 1)n - type principal sub - matrix (1 ≤ k < n, {x[i]|1 ≤ i ≤ k + 1} = {i|1 ≤ i ≤ k + 1}, {y[j]|1 ≤ j ≤ (k + 1)n} = {j|1 ≤ j ≤ (k + 1)n}, {y[j]|1 ≤ j ≤ kn} = {j|1 ≤ j ≤ kn}, {x[i]|1 ≤ i ≤ k} = {i|1 ≤ i ≤ k}); where each of the first k groups contains n row minimum elements, and the (k + 1)-th group contains r row minimum elements (1 ≤ r < n); A (k) , A (k-1) , Λ, A (2) , A (1) , A (0) is a matrix sequence obtained by successive transformations with A (k) as the initial matrix. The process of obtaining the matrix sequence is as follows: (1) In A (p) Add a constant c to each element in the column where the smallest element of the x[t]th group of rows is located p (1≤p≤k+1), where c p and x[t] is determined so that it satisfies (h ∈ {j|pn + r < j ≤ (k + 1)n}); (2) If x[p]≠x[t], and p>1, swap the row coordinates and column coordinates of the two groups of elements in the x[p] group with the x[t] group, and then swap the row coordinates and column coordinates of the two groups of elements in the x[p] group with the x[p-1] group, to obtain A. (p-1) , perform the operation p--subtracting 1 from p, and return to step (1) to calculate A. (p-2) ; (3) If x[p] = x[t] and p>1, swap the row coordinates and column coordinates of the two groups of elements of the x[p] group and the x[t] group. Then we get A. (p-1) , call the FullGoupChange(k) function to obtain the remaining subsequence A (p-2) ,A (p-3) , …, A (2) ,A (1) , A (0) ; (4) If x[p] = x[t] and p = 1, then we get A (p-1) , and you get A (0) ; So, with A (k) The matrix sequence A is obtained by gradually transforming the initial matrix (k) , A (k-1) , Λ, A (2) , A (1) , A (0) , then the final matrix The (k+1)×(k+1)n type principal matrix The elements have the following properties: 1) and is a principal submatrix of type (k + 1)×(k + 1)n among k + 1 independent row minimum tuples (1 ≤ k < n), ({x[i]|1 ≤ i ≤ k + 1} = {i|1 ≤ i ≤ k + 1}, {y[j]|1 ≤ j ≤ (k + 1)n} = {j|1 ≤ i ≤ (k + 1)n}), where each of the first k groups contains n row minimum elements, and the (k + 1)-th group contains r row minimum elements (1 ≤ r < n); 2) 3) The absentGoupExtendChange(k, r) function written according to Theorem 4 in programming is the definition of this function.

6. The method for assigning tasks based on n-person n-square tasks in a master matrix according to claim 1, characterized in that: The programming algorithm and function implementation of the absentGoupExtendLook(k, r) function in step S1 are based on the following theorem: Theorem 5: Let and be k + 1 independent row minimum tuples of a (k + 1)×(k + 1)n - type sub - matrix where (1 ≤ k < n), ({x[i]|1 ≤ i ≤ k} = {i|1 ≤ i ≤ k}, {y[j]|1 ≤ j ≤ kn} = {j|1 ≤ i ≤ kn}), ({x[i]|1 ≤ i ≤ k + 1} = {i|1 ≤ i ≤ k + 1}, {y[j]|1 ≤ j ≤ (k + 1)n} = {j|1 ≤ j ≤ (k + 1)n}), with each of the first k groups containing n row minimum elements and the (k + 1)-th group containing r row minimum elements (1 ≤ r < n) and (1) (2) Then in the (k+1)×(k+1)n type main matrix We can definitely find k+1 independent row minimum tuples: and Among them, {x[i]|1≤i≤k} = {i|1≤i≤k}, {y[j]|1≤j≤(k + 1)n} = {j|1≤j≤(k + 1)n}, x[k + 1] = k + 1, where each of the first k groups contains n row minimum elements, and the (k + 1)-th group contains r + 1 row minimum elements; The absentGoupExtendLook(k, r) function written according to Theorem 5 in programming is the definition of this function.

7. The method for assigning tasks based on n-person n-square tasks in a master matrix according to claim 1, characterized in that: In step S2, the matrix is ​​'used to Perform the same solution transformation to obtain the new matrix when k = 1 and its subarray And make the subarray All elements above are equal".

Images