Method, system and electronic device for balanced allocation of court cases based on integer programming

Abstract

The present invention provides a balanced case allocation method, system and electronic device based on integer programming. The balanced case allocation system includes: a judge ability assessment module, which is used to obtain judge information to generate judge characteristics and their lists, and to evaluate the judge's ability to obtain the judge's ability; a case difficulty assessment module, which is used to obtain case files to generate case characteristics and their lists, and to evaluate the difficulty of the case to obtain the difficulty of the case; a rule module, which is used to generate case allocation constraints according to case allocation rules; a case allocation module, which is used to determine the objective function according to the judge's ability and the case difficulty, and generate a balanced case allocation result that meets the constraints and optimizes the objective function; an output module, which is used to output the corresponding balanced case allocation result according to the output requirements. The present invention combines the advantages of random case allocation and manual case allocation, and generates a case allocation plan that meets the balanced target requirements on the premise of meeting the specified case allocation rules.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to the field of court case management technology. Background Art

[0002] At present, courts mostly use random or manual case assignment methods. Among them, random case assignment randomly assigns cases to judges. Although random case assignment reduces favoritism and fraud, the assignment plan is not fair and may generate case assignment plans that violate common sense and are not matched. Another major case assignment method is manual case assignment. Generally, professionals, such as the president of the court, are responsible for case assignment. Although manual case assignment can meet various complex requirements and match cases with judges, it is time-consuming and labor-intensive and there is a risk of favoritism and fraud.

[0003] At present, the objective function often used by the court when dividing cases is linear programming. Linear programming is a method of seeking the optimal solution for a linear objective based on certain constraints. The basic method for solving linear programming problems is the simplex method, that is, changing the variables within the range allowed by the constraints, finding the value of the corresponding optimization objective, and iterating repeatedly to seek the optimal solution. Depending on the complexity of the modeling, as the optimization objective becomes more complex and the number of constraints that need to be followed increases, the model often needs to go through more complex calculations to obtain the final optimization result.

[0004] Another objective function often used by the court when dividing cases is integer programming. Integer programming is based on linear programming and further requires that the values ​​of variables in the final solution are all integers. On the other hand, some of the solution methods used in linear programming, such as the simplex method, are not suitable for the solution model of integer programming. However, some integer programming models will try to solve the optimal solution by further integer iteration after solving the non-integer solution. For the solution method that does not perform iterative solution, the heuristic search method is often used to directly try all the combinations of variable values ​​that meet the constraints, and select the combination corresponding to the optimal objective function as the final result. Summary of the invention

[0005] In view of the above-mentioned shortcomings of the prior art, the purpose of the present invention is to provide a method, system and electronic device for balanced allocation of court cases based on integer programming, which are used to solve the technical problem in the prior art that courts cannot effectively allocate cases.

[0006] To achieve the above-mentioned purpose and other related purposes, the present invention provides a method for balanced allocation of court cases based on integer programming, including: obtaining judge information to generate judge characteristics and a list thereof, and evaluating the judge's ability to obtain the judge's ability; obtaining case files to generate case characteristics and a list thereof, and evaluating the difficulty of the case to obtain the difficulty of the case; generating case allocation constraints according to case allocation rules; determining an objective function according to the judge's ability and the case difficulty; generating a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function; and outputting the corresponding balanced case allocation result according to output requirements.

[0007] In one embodiment of the present invention, a method for implementing the evaluation of the judge's ability includes: Among them, α j Indicates the ability of judge j; c j is the total number of cases heard by judge j, c is the number of cases heard by judge j, a c The difficulty coefficient of different cases.

[0008] In one embodiment of the present invention, the factors affecting the difficulty of the case include: the type of case, the subject matter, the number of people involved and the file description.

[0009] In one embodiment of the present invention, the case division rules include one or more of the following combinations: the number of cases of a certain type heard by a certain judge is limited to a range; a certain judge must hear a certain case; a certain judge cannot hear a certain case; the number of cases heard by a certain judge is limited to a range; a certain case must be heard by one of certain judges; certain cases cannot be heard by the same judge at the same time.

[0010] In one embodiment of the present invention, the method for balanced distribution of court cases based on integer programming further includes: converting the preset case distribution rules into mathematical expressions to form mathematically expressed case distribution constraints.

[0011] In one embodiment of the present invention, integer programming is used to generate a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function; the integer programming represents the allocation relationship between cases and judges through a two-dimensional matrix.

[0012] An embodiment of the present invention also provides a court case balanced allocation system based on integer programming, characterized in that: the court case balanced allocation system based on integer programming includes: a judge ability assessment module, which is used to obtain judge information to generate judge characteristics and a list thereof, and evaluate the judge's ability to obtain the judge's ability; a case difficulty assessment module, which is used to obtain case files to generate case characteristics and a list thereof, and evaluate the difficulty of the case to obtain the difficulty of the case; a rule module, which is used to generate case allocation constraints according to case allocation rules; a case allocation module, which is used to determine the objective function according to the judge's ability and the case difficulty, and generate a balanced case allocation result that meets the constraints and optimizes the objective function; an output module, which is used to output the corresponding balanced case allocation result according to output requirements.

[0013] In one embodiment of the present invention, the factors affecting the difficulty of the case include: the type of case, the subject matter, the number of people involved and the file description.

[0014] In one embodiment of the present invention, the case division rules include one or more of the following combinations: the number of cases of a certain type heard by a certain judge is limited to a range; a certain judge must hear a certain case; a certain judge cannot hear a certain case; the number of cases heard by a certain judge is limited to a range; a certain case must be heard by one of certain judges; certain cases cannot be heard by the same judge at the same time.

[0015] An embodiment of the present invention further provides an electronic device, including a processor and a memory, wherein the memory stores program instructions; the processor executes the program instructions to implement the above-mentioned method for balanced allocation of court cases based on integer programming.

[0016] As described above, the court case balanced allocation method, system and electronic device based on integer programming of the present invention have the following beneficial effects:

[0017] The present invention combines the advantages of random case allocation and manual case allocation. The case allocation rules are explicitly written in the case allocation requirements as constraints and can be reviewed afterwards. The matching of cases and judges is solved by a customized objective function. The randomness and fairness of case allocation are solved by random selection in the optimal solution. On the premise of satisfying the specified case allocation rules, a case allocation plan that meets the equilibrium goal requirements is generated. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0019] Figure 1 Shown is a schematic diagram of the overall process of a balanced allocation method of court cases based on integer programming in one embodiment of the present application.

[0020] Figure 2 Shown is a principle block diagram of a court case balanced allocation system based on integer programming in one embodiment of the present application.

[0021] Figure 3 Shown is a principle block diagram of an electronic device in an embodiment of the present application.

[0022] Component number description

[0023] 100 Balanced distribution system of court cases based on integer programming 100

[0025] 110 Judge Competence Assessment Module

[0026] 120 Case Difficulty Assessment Module

[0027] 130 Rules Module

[0028] 140 Case Division Module

[0029] 150 Output Module

[0030] 101 Electronic Equipment

[0031] 1001 Processor

[0032] 1002 Memory

[0033] S100~S600 Steps DETAILED DESCRIPTION

[0034] The following describes the embodiments of the present invention by specific examples, and those skilled in the art can easily understand other advantages and effects of the present invention from the contents disclosed in this specification. The present invention can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed in various ways based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the following embodiments and features in the embodiments can be combined with each other without conflict.

[0035] The purpose of this embodiment is to provide a method, system and electronic device for balanced allocation of court cases based on integer programming, which are used to solve the technical problem in the prior art that courts cannot effectively allocate cases.

[0036] This embodiment uses integer programming to distribute cases. The case distribution rules are explicitly written in the case distribution requirements as constraints and can be reviewed later. The matching of cases and judges is solved by a customized objective function, and the randomness and fairness of case distribution are solved by random selection in the optimal solution of the requirements.

[0037] The principles and implementation methods of the method, system and electronic device for balanced distribution of court cases based on integer programming of the present invention will be described in detail below, so that those skilled in the art can understand the method, system and electronic device for balanced distribution of court cases based on integer programming of the present invention without creative work.

[0038] Example 1

[0039] Specifically, Figure 1 As shown, this embodiment provides a balanced allocation method for court cases based on integer programming, and the balanced allocation method for court cases based on integer programming includes:

[0040] Step S100, obtaining judge information to generate judge characteristics and a list thereof, and evaluating the judge's ability to obtain the judge's ability;

[0041] Step S200, obtaining the case file to generate case features and their list, and evaluating the difficulty of the case to obtain the difficulty of the case;

[0042] Step S300, generating case division constraint conditions according to the case division rules;

[0043] Step S400, determining an objective function according to the judge's ability and the difficulty of the case;

[0044] Step S500, generating a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function;

[0045] Step S600: output the corresponding balanced case distribution result according to the output requirement.

[0046] The following is a detailed description of steps S100 to S600 of the method for balanced allocation of court cases based on integer programming in this embodiment.

[0047] Step S100, obtaining judge information to generate judge characteristics and a list thereof, and evaluating the judge's ability to obtain the judge's ability.

[0048] This embodiment assumes that the judge information has been digitized and stored in a database. The judge information includes but is not limited to the judge's personal information, such as position, education and age, and also includes the judge's case history. The judge's characteristics, that is, the judge's portrait, are constructed through the above judge information. In software design, the concept of judge corresponds to a class, and the attributes of the class are the various attributes obtained from the judge's portrait. Each specific judge corresponds to an instance of this class. In integer programming, each specific judge corresponds to a dimension of the search space, and its attributes can be used to customize the optimization objective function. For example, a court has twenty judges. In this method, the judge dimension of integer programming has twenty corresponding items. In order to facilitate calculation later, the judge's attributes need to be quantified. Among them, the judge's personal information is quantified by enumeration, and the judge's ability is obtained by calculating his case history.

[0049] In this embodiment, the judge's historical case information is used to evaluate the judge's ability.

[0050] Specifically, in this embodiment, one implementation of evaluating the judge's ability includes:

[0051] Among them, α j represents the ability of judge j; c j is the total number of cases heard by judge j, c is the number of cases heard by judge j, a c The difficulty coefficient of different cases.

[0052] Assess the judge's ability to hear cases through the cases he has tried. It means that the ability of judge j is determined by the cases he has tried in the past month, and c is the case tried by judge j. Different types of cases will be assigned different difficulty coefficients. That is, for different cases c, a c The value of is different, and the specific value selection method is affected by the length of the case trial and the type of case. The judge's ability value is the sum of the weighted difficulty of different cases.

[0053] Specifically, the judge's personal ability is calculated based on the cases he has heard in the past period of time. The difficulty of each case is related to the case type and the trial period. The ability assessment of a judge is mainly calculated based on the cases he has heard in the past period of time.

[0054] Taking judge i as an example, another specific calculation process for evaluating the judge's ability is:

[0055] In the formula, ability(i) is the ability of the judge, T represents the type of case, including criminal cases, civil cases, political cases, etc., α t and d t (i) represents the difficulty ratio of type t cases and the average difficulty of type c cases heard by judge i in the past period of time. t It is set by the user when using it. If there are case types that the judge has not heard before, regularization and regularization are used to ensure that the final ability assessment of all judges remains at the same level.

[0056] Step S200, obtaining the case file to generate case features and their list, and evaluating the difficulty of the case to obtain the difficulty of the case.

[0057] In this embodiment, it is assumed that the case file information has been digitized and stored in a database. This embodiment evaluates the difficulty of the case through a set of indicator systems. Each indicator system has a corresponding score. For example, there is a corresponding score for each type of case. After scoring all indicators, the corresponding weights are assigned according to the importance of each indicator, and the total difficulty value is summed up. The weights here are obtained by comprehensively considering experts and historical analysis. For example, the score of a case type is obtained by analyzing the average closing time of all cases of that type, and its weight is assessed by court experts.

[0058] In this embodiment, factors affecting the difficulty of the case include, but are not limited to: the type of case, the subject matter, the number of persons involved, and the file description.

[0059] In this embodiment, a set of index systems established through experience is used. The index system includes the type of case, the number of people involved and the subject matter, and then the weighted sum of all the indexes is used to evaluate the difficulty of a case.

[0060] That is, in this embodiment, the complexity of the case is determined based on the type of case, the subject matter, the number of people involved and the file description, and a numerical value describing the complexity of the case is obtained.

[0061] Step S300, generating case division constraint conditions according to the case division rules.

[0062] Case assignment rules include common conflicts of interest, designated trials, etc. After establishing a list of cases and judges, the present invention uses a two-dimensional matrix to represent the assignment relationship between cases and judges. Assume that a value in this matrix is ​​mij, where 1 means that the i-th case is heard by the j-th judge; 0 means that the i-th case is not heard by the j-th judge. In this way, the rules can be transformed into the designation of values ​​on this matrix. For example, if the conflict of interest requires that the i-th case cannot be heard by the j-th judge, then mij is set to 0. For another example, if the j-th judge is required to hear no more than n cases, then ∑ i m ij <n, the sum of the jth column must be less than n.

[0063] In this embodiment, users can add some restrictions to the case assignment according to the actual situation. In actual use, some judges may only be able to hear certain types of cases, such as civil court judges should not be assigned to hear criminal or political cases. In some cases, there are situations where relatives avoid. These restrictions can be set. In this embodiment, the priority attribute is set during the addition process. For the restriction conditions of the rule category, a high priority can be set to ensure that the requirements are met.

[0064] Specifically, in this embodiment, the division rules include one or more of the following combinations:

[0065] 1) The number of cases of a certain type heard by a judge is limited to a certain range;

[0066] 2) A certain judge must hear a certain case;

[0067] 3) A certain judge cannot hear a certain case;

[0068] 4) The number of cases heard by a certain judge first peaks in a certain range;

[0069] 5) A case must be heard by one of certain judges;

[0070] 6) Certain cases cannot be heard by the same judge at the same time.

[0071] For the above case division rules, when there is a conflict between the added constraints, the constraints added first can be retained first, and the user is reminded of the corresponding conflicting constraints. Furthermore, in this embodiment, the case division rules customized by the user are converted into conditional constraints in the form of mathematical expressions.

[0072] That is, in this embodiment, the method for balanced distribution of court cases based on integer programming also includes: converting the preset case distribution rules into mathematical expressions to form mathematically expressed case distribution constraints.

[0073] This embodiment receives unstructured data and converts it into corresponding types of restriction conditions.

[0074] Conditional transformation structures the added constraints and finally adds them to integer programming in the form of equality or inequality.

[0075] First, the entire problem definition is transformed into a matrix definition. For M judges and N cases to be heard, what needs to be solved is an M×N matrix P, where P(i,j)=1 means that case j is assigned to judge i for trial. Then the most basic restriction is that the sum of each column in P is 1, that is:

[0076] Secondly, for the above-mentioned restrictions, establish restrictions according to the corresponding requirements and give specific ways to add them:

[0077] 1) The number of cases of a certain type heard by a judge is limited to a certain range:

[0078] The number of cases of a certain type c heard by a judge i is limited to an interval [lb,ub]:

[0079]

[0080] 2) A judge must hear a case:

[0081] A judge i must hear a case j: Pi,j=1.

[0082] 3) A judge cannot hear a case:

[0083] A judge i cannot hear a case j: Pi,j=0.

[0084] 4) The number of cases heard by a judge first reaches a certain range:

[0085] The number of cases heard by a judge is first within a range [lb,ub]:

[0086]

[0087] 5) A case must be heard by one of certain judges:

[0088] A case i must be heard by one of some set of judges J:

[0089]

[0090] 6) Certain cases cannot be heard by the same judge at the same time:

[0091] Some set of cases C cannot be heard by the same judge i at the same time:

[0092]

[0093] After all these restrictions are converted, this embodiment also includes conflict detection for these restrictions, and deletes the conflicting conditions that are added later. For example, a case is required to be assigned to two different judges at the same time, or a case is required to be heard by a certain judge before, but it is later determined that the judge cannot hear the case. Of course, there will be some implicit conflicts, such as due to multiple case assignments, some judges are ultimately unable to meet the restrictions on the number of cases to be heard.

[0094] In these cases, this embodiment will ignore the restriction conditions added later, and input the restriction condition information added later into the conflict information, so that the user can check the conflict after obtaining the result.

[0095] This embodiment estimates the judge's personal ability through the cases he has tried in the past and personal information such as the department, age, gender, and working hours. The complexity of the case is evaluated by processing the text content of the appeal, including the cause of action, information of the plaintiff and the defendant, etc. In addition, additional restrictions of different formats and types are converted into mathematical expressions. The judge's ability and the difficulty of the case are then taken into account. The goals are to reduce the difference in the time it takes for a judge to try all his cases and the sum of the time required for all judges to complete their assigned tasks. Cases are allocated by adding certain weights through integer optimization, and two automatic case allocation methods, balanced case allocation and efficient case allocation, are obtained.

[0096] This embodiment further converts the added constraints into mathematical expressions for subsequent integer optimization. For different types of constraints, such as constraint types a, c, d, and f, the constraint conversion is performed using the quantized form of interval inequalities, and for the remaining constraint types, the constraint conversion is performed using the quantized form of equations. Moreover, for the above constraint types, when there is a conflict between the added constraints, the higher priority constraint can be prioritized. When the priorities are equal, the first added constraint is retained first, and the system user is reminded of the corresponding conflicting constraints.

[0097] Step S400, determining an objective function according to the judge's ability and the difficulty of the case.

[0098] This embodiment supports various defined balance requirements. To this end, this embodiment predefines multiple objective functions. One objective function is to assign the same number of cases to each judge. According to the objective function selected by the user, integer programming is used to obtain feasible solutions, and the optimal solution is selected from the feasible solutions. In this process, a multiple breakpoint mechanism is set to ensure that the number of results finally returned reaches a threshold or the time of the heuristic search reaches a threshold, thereby ensuring the efficiency of case distribution.

[0099] Step S500, generating a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function.

[0100] In this embodiment, complex integer programming is used to take into account the ability of the judge and the difficulty of the case, and certain weights are added to allocate cases. The optimization objective function is selected according to the requirements of equilibrium, and integer programming is used to generate a solution that meets the constraints and optimization goals and has random characteristics. From the perspective of optimization, it means that some values ​​in the two-dimensional matrix of case-judge have been determined. Under this limitation, other undefined values ​​are adjusted to generate new solutions. According to the objective function, a corresponding fitness value can be calculated from each generated solution. The objective function can be customized according to the needs of the court. For example, if some courts pay more attention to professional matching, the fitness value that is more relevant to professional matching can be calculated based on the generated solution. Since all case allocations in each solution have been determined, various customized objective functions can be calculated to obtain fitness values ​​that meet various needs.

[0101] This embodiment uses various search algorithms to change better solutions from existing solutions. These algorithms obtain new solutions by modifying certain values ​​in existing solutions, and this process continues until no solution with better fitness value can be found after predetermined attempts. For example, a 20X10 matrix is ​​generated by 20 cases and 10 judges. Since there are only two possible values, 0 and 1, the search space is not large, and even some violent traversal methods can be used to generate solutions. The introduction of rules will limit the values ​​of certain rows and columns in the matrix, which will further narrow the scope of search. Since most search algorithms have certain random factors, the allocation results of cases have certain random properties. The rule constraints of the case are generally not limited to only one solution. In most cases, there are multiple solutions. Due to the existence of the above-mentioned random factors, which solution is output is random. Therefore, it can also prevent favoritism and fraud to a certain extent.

[0102] Given a set of cases, a set of judges, and some limiting conditions, although there are multiple solutions, only one solution is needed to allocate the cases in actual case allocation. In order to meet the efficiency of case allocation, the search can be exited when a solution is generated. In order to prevent favoritism and fraud, it can also be exited after several solutions are generated. The specific solution is selected and then completed in a random manner. In this way, the case allocation plan generated by this embodiment satisfies both professional matching and manual rules, and also satisfies the random case allocation plan.

[0103] During the case distribution process, new cases may need to be distributed before the existing case distribution plan is fully implemented. For example, a judge is very efficient and has heard all the assigned cases. At the same time, there is a backlog of new cases, but other judges may not have heard the assigned cases yet. In this case, it may be necessary to distribute cases on the premise that some distribution plans already exist. The method adopted in this embodiment is to expand the two-dimensional matrix representing the case-judge distribution, and add new cases or judges to the existing case distribution matrix. The existing case distribution plan serves as a constraint, that is, an unchangeable value. At the same time, on this basis, a solution that meets the optimization goal is searched. In this way, a case distribution plan that meets the optimization goal and takes into account the existing distribution can be obtained.

[0104] Specifically, integer programming is used to generate a balanced case distribution result that satisfies the constraints and optimizes the objective function; the integer programming represents the distribution relationship between cases and judges through a two-dimensional matrix. One dimension is the case and the other dimension is the judge. The value of the matrix is ​​either 0 or 1, where 0 indicates that a case cannot be given to the corresponding judge and 1 indicates that the case should be given to the corresponding judge. Using an integer optimization algorithm, cases are distributed based on the judge's ability and the difficulty of the case, and the goal of balanced case distribution is determined by the objective function. This embodiment is introduced by taking two optimization objectives as an example. However, this embodiment is not limited to the following two optimization objectives. Other optimization objectives that other technicians have made no creative changes to also fall within the scope of protection of the present invention.

[0105] 1) Targeting the number of judges’ cases

[0106] This embodiment first proposes an integer programming method for assigning cases based on the number of cases being tried by a judge, so as to ensure that the number of cases accepted by each judge at the same time is as balanced as possible. For this optimization goal, in fact, it is only necessary to divide the total number of cases that need to be accepted by the total number of judges M / N to obtain the number of cases that should be assigned to each judge.

[0107] However, in actual operation, the complexity of each case is different, so the time required to complete the trial of each case is also different. Therefore, the goal to be optimized in this embodiment is to minimize the difference in the time it takes for judges to complete the trial of all cases.

[0108] In view of the above goals, the following optimization objectives are given: Where Pi represents the sum of the i-th row in the optimization matrix, that is, the total number of cases heard by judge i. Of course, this optimization goal first ensures that all constraints added in the previous module are met.

[0109] In fact, in addition to the trial time of each case, the difficulty of the case will also be different. Similarly, the ability of each judge will also be different. Therefore, we further refine the original trial time. For a judge i and case c, this embodiment defines the time required for the judge to hear the case: In addition, the total difficulty of cases heard by a judge at the same time should not exceed the upper limit of his or her ability.

[0110] Finally, the optimized function is:

[0111]

[0112]

[0113] For the complexity(c j ) and ability(i) are directly calculated from the previously obtained case difficulty assessment and judge ability assessment. Similarly, this optimization function also needs to satisfy all the constraints added previously.

[0114] In actual use, some judges may only be able to hear certain types of cases, such as civil court judges should not be assigned to hear criminal or political cases. In some cases, there are situations where relatives avoid the case. These restrictions can be added according to actual conditions. In this embodiment, the priority attribute is set during the addition process, and a high priority can be set for the restriction conditions of the rule category to ensure that the requirements are met.

[0115] 2) Targeting judge-case matching

[0116] This example also models the efficient case assignment - judge-case matching as the goal, and obtains the optimization goal:

[0117]

[0118]

[0119] Unlike the previous goal of balanced case distribution, the optimization function with matching as the goal is directly the sum of the time required for all judges to complete their assigned tasks. Without any processing of the required time, this sum of time will not change, but similar to the previous balanced case distribution of the court, this embodiment believes that experienced judges can hear cases of the same difficulty in a shorter time than inexperienced judges. Therefore, the same case requires different processing time for different judges, so this goal can be optimized.

[0120] In addition, in this embodiment, all case allocation plans are generated at the same time. In this embodiment, the result of integer programming is converted into a case allocation result and returned. The returned case allocation result generally corresponds to all judges and a large number of cases. When there is no feasible solution, all conflicting constraints are returned.

[0121] In particular, in this embodiment, it is supported to add new cases and judges based on the existing case division plan, that is, to convert the existing case division plan into constraints in integer programming. The newly added cases and judges are solved again using integer programming under the condition that the above constraints are met, so as to generate a new case division plan that does not violate the existing case division plan and tries to meet the equilibrium objective function.

[0122] Step S600: output the corresponding balanced case distribution result according to the output requirement.

[0123] The result of integer programming is converted into a case division result and returned. The returned case division result generally corresponds to the number of cases for all judges.

[0124] This embodiment uses heuristic search to solve the goal of integer programming, finds the optimal solution to the objective function among the solutions that meet all constraints, and outputs the case distribution results in the form of a two-dimensional matrix in the form of a dictionary. Specifically, the output is a list of cases assigned to each judge and a representative for the judge to hear.

[0125] That is, all the solutions output by this embodiment are two-dimensional matrices. One dimension represents the case and the other dimension represents the judge. This output may not be suitable for some specific scenarios and is not intuitive enough. It needs to be adjusted according to the specific needs of the court. For example, it may be necessary to cut out the cases that are handled by a certain court within the court. In addition, there may be a situation where a valid solution cannot be generated due to a conflict of manually customized rules. For example, due to a conflict of interest, the i-th case cannot be heard by the j-th judge, but at the same time another rule specifies that the case to which the i-th case belongs must be heard by the j-th judge.

[0126] Therefore, the balanced case allocation method of the court based on integer programming in this embodiment combines the advantages of random case allocation and manual case allocation, and can generate a case allocation plan that meets both random and balanced requirements under the premise of meeting the rules specified by the judge.

[0127] Example 2

[0128] like Figure 2 As shown, this embodiment provides a court case balanced allocation system 100 based on integer programming, and the court case balanced allocation system 100 based on integer programming includes: a judge ability assessment module 110, a case difficulty assessment module 120, a rule module 130, a case division module 140 and an output module 150.

[0129] In this embodiment, the judge ability evaluation module 110 is used to obtain judge information, generate judge characteristics and a list thereof, and evaluate the judge's ability to obtain the judge's ability.

[0130] In this embodiment, the case difficulty assessment module 120 is used to obtain case files to generate case features and a list thereof, and to assess the difficulty of the case to obtain the difficulty of the case.

[0131] Specifically, in this embodiment, the factors affecting the difficulty of the case include, but are not limited to: the type of case, the subject matter, the number of people involved, and the file description.

[0132] In this embodiment, the rule module 130 is used to generate case division constraints according to the case division rules.

[0133] Specifically, in this embodiment, the case division rules include one or more of the following combinations: the number of cases of a certain type heard by a certain judge is limited to a range; a certain judge must hear a certain case; a certain judge cannot hear a certain case; the number of cases heard by a certain judge is limited to a range; a certain case must be heard by one of certain judges; certain cases cannot be heard by the same judge at the same time.

[0134] In this embodiment, the case assignment module 140 is used to determine the objective function according to the ability of the judge and the difficulty of the case, and to generate a balanced case assignment result that satisfies the constraint conditions and optimizes the objective function; the output module 150 is used to output the corresponding balanced case assignment result according to the output requirements.

[0135] The technical features specifically implemented by the court case balanced allocation system 100 based on integer programming in this embodiment are basically the same as the court case balanced allocation method based on integer programming in the aforementioned embodiment, and the technical contents that can be commonly used between the embodiments will not be repeated.

[0136] It should be noted that it should be understood that the division of the various modules of the above device is only a division of logical functions. In actual implementation, they can be fully or partially integrated into one physical entity, or they can be physically separated. And these modules can all be implemented in the form of software called by processing elements; they can also be all implemented in the form of hardware; some modules can also be implemented in the form of software called by processing elements, and some modules can be implemented in the form of hardware. For example, the rule module 130 can be a separately established processing element, or it can be integrated in a certain chip of the electronic terminal. In addition, it can also be stored in the memory of the terminal in the form of program code, and called and executed by a certain processing element of the above terminal. The function of the above tracking calculation module. The implementation of other modules is similar. In addition, all or part of these modules can be integrated together, or they can be implemented independently. The processing element described here can be an integrated circuit with signal processing capabilities. In the implementation process, each step of the above method or each module above can be completed by an integrated logic circuit of hardware in the processor element or instructions in the form of software.

[0137] For example, the above modules may be one or more integrated circuits configured to implement the above methods, such as one or more application specific integrated circuits (ASIC), or one or more digital singnal processors (DSP), or one or more field programmable gate arrays (FPGA). For another example, when a module is implemented in the form of a processing element scheduling program code, the processing element may be a general-purpose processor, such as a central processing unit (CPU) or other processors that can call program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).

[0138] Example 3

[0139] like Figure 3As shown, this embodiment provides an electronic device 101, and the electronic device 101 includes: a processor 1001 and a memory 1002; the memory 1002 is used to store a computer program; the processor 1001 is used to execute the computer program stored in the memory 1002, so that the electronic device 101 performs each step of the balanced allocation method of court cases based on integer programming in Example 1. Since the specific implementation process of each step has been described in detail in Example 1, it will not be repeated here.

[0140] The processor 1001 is a CPU (Central Processing Unit). The memory 1002 is connected to the processor 1001 through a system bus and communicates with each other. The memory 1002 is used to store computer programs, and the processor 1001 is used to run computer programs so that the processor 1001 executes the method for balanced allocation of court cases based on integer programming. The memory 1002 may include a random access memory (RAM), and may also include a non-volatile memory, such as at least one disk storage.

[0141] In addition, this embodiment further provides a computer-readable storage medium on which a computer program is stored, and when the computer program is executed by the processor 1001, the balanced allocation method of court cases based on integer programming is implemented. The balanced allocation method of court cases based on integer programming has been described in detail above, and will not be repeated here.

[0142] Those skilled in the art can understand that all or part of the steps of implementing the above-mentioned method embodiments can be completed by hardware related to the computer program. The aforementioned computer program can be stored in a computer-readable storage medium. When the program is executed, the steps of the above-mentioned method embodiments are executed; and the aforementioned storage medium includes: ROM, RAM, magnetic disk or optical disk and other media that can store program codes.

[0143] In summary, the present invention combines the advantages of random case allocation and manual case allocation. The case allocation rules are explicitly written in the case allocation requirements as constraints, which can be checked later. The matching of cases and judges is solved by a customized objective function. The randomness and fairness of case allocation are solved by random selection in the optimal solution of the requirements. On the premise of meeting the specified case allocation rules, a case allocation plan that meets the equilibrium objective requirements is generated. Therefore, the present invention effectively overcomes various shortcomings in the prior art and has a high industrial utilization value.

[0144] The above embodiments are merely illustrative of the principles and effects of the present invention, and are not intended to limit the present invention. Anyone familiar with the art may modify or alter the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical ideas disclosed by the present invention shall still be covered by the claims of the present invention.

Claims

1. A balanced allocation method for court cases based on integer programming, characterized by: include: Obtain judge information to generate judge characteristics and their lists, and evaluate judge abilities to obtain judge abilities; One implementation of the evaluation of the judge's ability includes: Among them, α j represents the ability of judge j; c j is the total number of cases heard by judge j, c is the number of cases heard by judge j, a c Difficulty coefficients for different cases; obtain case files to generate case features and their lists, and evaluate the difficulty of the cases to obtain the difficulty of the cases; According to the case division rules, case division constraints are generated; the case division rules include one or more of the following combinations: the number of cases of a certain type heard by a certain judge is limited to a certain range; a certain judge must hear a certain case; a certain judge cannot hear a certain case; the number of cases heard by a certain judge must be within a certain range; a certain case must be heard by one of certain judges; certain cases cannot be heard by the same judge at the same time; Determine the objective function according to the judge's ability and the difficulty of the case; in the objective function determined according to the judge's ability and the difficulty of the case: take the number of judge's cases as the target, the objective function is: Or in the objective function determined according to the judge's ability and the case difficulty: taking the judge-case matching degree as the goal, the objective function is: Where Pi represents the total number of cases heard by judge i, Pi,j means case j is assigned to judge i for trial, N is the total number of cases to be heard, M is the total number of judges, ability(i) is the ability of judge i, c j is the total number of cases heard by judge j, complexity(c j ) represents the case difficulty assessment; Generate a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function; Output the corresponding balanced case distribution results according to the output requirements.

2. The method for balanced allocation of court cases based on integer programming according to claim 1, characterized in that: Factors influencing the difficulty of the case include: case type, subject matter, number of persons involved and case file description.

3. The method for balanced allocation of court cases based on integer programming according to claim 1, characterized in that: The method for balanced distribution of court cases based on integer programming also includes: converting the preset case distribution rules into mathematical expressions to form mathematically expressed case distribution constraints.

4. The method for balanced allocation of court cases based on integer programming according to claim 1 is characterized in that: Integer programming is used to generate a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function; the integer programming represents the allocation relationship between cases and judges through a two-dimensional matrix.

5. A court case balanced allocation system based on integer programming, characterized by: The court case balanced allocation system based on integer programming includes: The judge ability assessment module is used to obtain judge information, generate judge characteristics and their lists, and assess the judge's ability to obtain the judge's ability; one implementation method of assessing the judge's ability includes: Among them, α j represents the ability of judge j; c j is the total number of cases heard by judge j, c is the number of cases heard by judge j, a c The difficulty coefficient of different cases; the case difficulty assessment module is used to obtain case files to generate case features and their lists, and to assess the difficulty of the case to obtain the difficulty of the case; A rule module is used to generate case division constraints according to the case division rules; the case division rules include one or more of the following combinations: the number of cases of a certain type heard by a certain judge is limited to a certain range; a certain judge must hear a certain case; a certain judge cannot hear a certain case; the number of cases heard by a certain judge must be within a certain range; a certain case must be heard by one of certain judges; certain cases cannot be heard by the same judge at the same time; The case allocation module is used to determine the objective function according to the judge's ability and the difficulty of the case, and generate a balanced case allocation result that satisfies the constraint conditions and optimizes the objective function; in the objective function determined according to the judge's ability and the difficulty of the case: taking the number of judge's cases as the target, the objective function is: Or in the objective function determined according to the judge's ability and the case difficulty: taking the judge-case matching degree as the goal, the objective function is: Where Pi represents the total number of cases heard by judge i, Pi,j means case j is assigned to judge i for trial, N is the total number of cases to be heard, M is the total number of judges, ability(i) is the ability of judge i, c j is the total number of cases heard by judge j, complexity(c j ) represents the case difficulty assessment; the output module is used to output the corresponding balanced case distribution results according to the output requirements.

6. The court case balanced allocation system based on integer programming according to claim 5 is characterized by: Factors influencing the difficulty of the case include: case type, subject matter, number of persons involved and case file description.

7. An electronic device, characterized in that: It includes a processor and a memory, wherein the memory stores program instructions; the processor runs the program instructions to implement the court case balanced allocation method based on integer programming as described in any one of claims 1 to 4.

Images