Information processing device, solution-finding method, and solution-finding program

Abstract

To provide an information processor that shortens solution-finding time for a linear programming problem.SOLUTION: An information processor 101 determines, on the basis of allowable time required for solution-finding on a linear programming problem to be solved, division granularity of a linear programming problem. The information processor 101 creates an objective function of each partial problem divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem. The information processor 101 creates, on the basis of a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem, a constraint equation for each partial problem. The information processor 101 obtains, by solving each partial problem in order on the basis the objective function and the constraint equation created for each partial problem, a solution of the linear programming problem.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present invention relates to an information processing device, a solution-finding method, and a solution-finding program. [Background technology]

[0002] In recent years, against the backdrop of labor shortages, there has been a growing need for services that utilize on-site data to match people with things and events and improve operational efficiency in various industries, such as transportation, human resource management, and nursing care facilities.In addition, linear programming is sometimes used to allocate shifts for nurses in hospitals and operators in call centers.

[0003] In the prior art, there is a method for extracting progress plan input data for a target period, determining calculation units for dividing the target period into multiple parts based on regression data so as to satisfy constraint conditions, and sequentially creating progress plans for each calculation unit from the progress plan input data to create a progress plan for the target period. The regression data corresponds to the scale parameter of the progress plan input data.

[0004] There is also a technique for creating an objective function from given environmental variables and state variables and finding the minimum value of the objective function. There is also a technique for accepting a specification of the accuracy of the creation of a plan for allocating work processes to resources, and creating a plan based on an algorithm corresponding to that creation accuracy and a termination condition for the creation of the plan corresponding to that creation accuracy. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] Japanese Patent Application Laid-Open No. 2009-258969 [Patent Document 2] Japanese Patent Application Publication No. 5-204891 [Patent Document 3] Japanese Patent Application Publication No. 2018-190417 Summary of the Invention [Problem to be solved by the invention]

[0006] However, in the conventional techniques, the size of the linear programming problem becomes large, and there are cases where the user is unable to solve the problem within an acceptable time.

[0007] In one aspect, the present invention aims to reduce the time required to solve a linear programming problem. [Means for solving the problem]

[0008] In one embodiment, there is provided an information processing device having a control unit that executes processing to determine a division granularity for dividing a linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved, create objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem, create constraint equations for each of the subproblems based on a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem, and find a solution to the linear programming problem by solving each of the subproblems in order based on the objective function and the constraint equations created for each of the subproblems. [Effects of the Invention]

[0009] Advantageous Effects of Invention According to one aspect of the present invention, an effect is achieved in that the time required to solve a linear programming problem can be reduced. [Brief explanation of the drawings]

[0010] [Figure 1] FIG. 1 is an explanatory diagram showing an example of a solution-finding method according to an embodiment. [Figure 2] FIG. 2 is an explanatory diagram showing an example of the system configuration of the information processing system 200. As shown in FIG. [Figure 3] FIG. 3 is a block diagram showing an example of the hardware configuration of the solution-finding processor 201. [Figure 4] FIG. 4 is an explanatory diagram showing an example of the contents stored in the past case DB 220. As shown in FIG. [Figure 5] FIG. 5 is an explanatory diagram showing a specific example of a linear programming problem to be solved. [Figure 6] FIG. 6 is a block diagram showing an example of the functional configuration of the solution-finding processor 201. [Figure 7] FIG. 7 is an explanatory diagram showing the correspondence relationship between problem size and solution time. [Figure 8] FIG. 8 is an explanatory diagram showing a specific example of a prediction model. [Figure 9] FIG. 9 is an explanatory diagram showing an example of dividing the original problem. [Figure 10] FIG. 10 is an explanatory diagram showing an example of extraction of allocation result data. [Figure 11] FIG. 11 is an explanatory diagram (part 1) showing an example of creating constraint equations for subproblems. [Figure 12] FIG. 12 is an explanatory diagram (part 2) showing an example of creating constraint equations for subproblems. [Figure 13] FIG. 13 is an explanatory diagram (part 3) showing an example of creating constraint equations for subproblems. [Figure 14A] FIG. 14A is an explanatory diagram (part 1) showing a specific example of the solution-finding process. [Figure 14B] FIG. 14B is an explanatory diagram (part 2) showing a specific example of the solution-finding process. [Figure 15] FIG. 15 is a flowchart showing an example of the allocation processing procedure of the solution-finding processing device 201. [Figure 16] FIG. 16 is a flowchart illustrating an example of a specific processing procedure for the allowable size search process. [Figure 17] FIG. 17 is a flowchart illustrating an example of a specific processing procedure for the problem division processing. [Figure 18] FIG. 18 is a flowchart illustrating an example of a specific processing procedure for the rule extraction processing. [Figure 19] FIG. 19 is a flowchart showing an example of a specific processing procedure of the solution-finding process. DETAILED DESCRIPTION OF THE INVENTION

[0011] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, with reference to the accompanying drawings, an information processing device, a solution-finding method, and a solution-finding program according to embodiments of the present invention will be described in detail.

[0012] (Embodiment) FIG. 1 is an explanatory diagram showing an example of a solution-finding method according to an embodiment. In FIG. 1, an information processing device 101 is a computer that solves a linear programming problem. A linear programming problem is an optimization problem in which the objective function is a linear function and the constraints can be described by equations or inequalities of the linear function. Furthermore, solving a linear programming problem means finding values of variables that optimize (maximize or minimize) the objective function under the constraints.

[0013] Here, linear programming may be used to match people with things and events. For example, when creating nurse work schedules, shift assignment work that has previously been done manually by experienced staff may be automated using linear programming.

[0014] In addition, when creating a schedule for the use of operating rooms, medical equipment, etc., there are cases where it is desirable to automate the allocation work that has been performed manually up until now. Also, when allocating operator shifts in a call center, there are cases where it is desirable to automate the allocation work that has been performed manually up until now.

[0015] As an example, in the case of nurse shift assignment, by formulating a linear programming problem as an optimization problem to find the combination of nurses and each day's work shift (day shift, night shift, late-night shift, etc.), it is possible to solve the linear programming problem using an existing solver. At this time, various constraints such as legal requirements, personal preferences, and work conditions are set.

[0016] For example, legal requirements include a maximum number of working hours per week and intervals between shifts. Personal preferences include requests for vacations and training. Work conditions include evenly allocating late-night and early-morning shifts and ensuring that work start times do not vary too much.

[0017] On the other hand, the time (computational complexity) required to solve a linear programming problem increases exponentially as the problem size increases. Problem size is expressed, for example, by the number of elements (e.g., people, objects, events) included in the linear programming problem and the number of constraints (constraint conditions) associated with them.

[0018] When the size of a linear programming problem becomes large, it may be difficult for the user to solve it within an acceptable time. For this reason, it may be possible to divide the problem into multiple subproblems to reduce the number of elements. However, the same problem of being unable to solve the subproblems within an acceptable time may occur.

[0019] Also, depending on how the subproblems are created, they may not be solvable. For example, suppose that when assigning shifts for one month, a condition is that Person A's shift must be assigned to Sunday three times during the month. Also, suppose that the problem is divided into subproblems for one week, and the selection of whether Person A's Sunday shift should be on or off is made. In this case, if Person A's shift is set to off on the first, second, and third Sundays, for example, the problem will not be solvable.

[0020] Here, when there are constraints that must be satisfied by multiple elements (people, things, events), even if only a part of it is extracted, the constraints that must be satisfied will still exist. Therefore, in this embodiment, we will explain a solution-finding method that extracts the constraints that must be satisfied for that part from past allocation result data and uses them to solve the problem, thereby quickly obtaining a solution (approximate solution) that satisfies the constraints throughout the entire problem.

[0021] An example of processing by the information processing device 101 will be described below.

[0022] (1) The information processing device 101 determines a division granularity of a linear programming problem based on an allowable time required for solving the linear programming problem to be solved. Here, the division granularity is a unit for dividing the linear programming problem into a plurality of subproblems. The linear programming problem includes an objective function and a set of constraints.

[0023] The objective function is the function to be maximized or minimized in an optimization problem. The objective function is expressed by a linear expression that includes variables. The constraint set is a set of constraints (constraint conditions) that the variables must satisfy. The allowable time can be set arbitrarily, for example, to the time that the user is willing to accept.

[0024] Specifically, for example, the information processing device 101 searches for the maximum problem size that can be solved within the allowable time based on the problem size of the linear programming problem and the allowable time, and then determines the division granularity of the linear programming problem based on the searched maximum problem size.

[0025] 1, the linear programming problem to be solved is designated as a "linear programming problem 110," the objective function of the linear programming problem 110 is designated as an "objective function 120," and the group of constraints is designated as a "group of constraints 130." It is also assumed that the division granularity d of the linear programming problem 110 is determined based on the allowable time required to solve the linear programming problem 110.

[0026] (2) The information processing device 101 creates objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem. Specifically, for example, the information processing device 101 extracts variables corresponding to each subproblem from the linear programming problem.

[0027] For example, when dividing a linear programming problem by a period (number of days), the variables corresponding to each subproblem are variables included in the period corresponding to each subproblem. Furthermore, when dividing a linear programming problem by the number of people, the variables corresponding to each subproblem are variables for the number of people corresponding to each subproblem. Then, the information processing device 101 creates an objective function for each subproblem by removing variables different from the extracted variables from the objective function of the linear programming problem.

[0028] 1, the sub-problems divided from the linear programming problem 110 based on the division granularity d are referred to as "sub-problems 110-1 and 110-2." Taking the sub-problem 110-1 as an example, an objective function 120-1 for the sub-problem 110-1 is created by removing variables different from the variables corresponding to the sub-problem 110-1 from the objective function 120 (original objective function) of the linear programming problem 110.

[0029] (3) The information processing device 101 creates constraint equations for each subproblem based on a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem. The past allocation result data is past allocation result data corresponding to the linear programming problem to be solved, and indicates, for example, shift allocation results for the same person for the same period (number of days) as the linear programming problem to be solved.

[0030] Specifically, for example, the information processing device 101 creates a first constraint equation for each subproblem by extracting a constraint equation that is true only for variables included in each subproblem from the group of constraint equations of the linear programming problem. Also, the information processing device 101 creates a second constraint equation for each subproblem based on the remaining constraint equations excluding the first constraint equation from the group of constraint equations of the linear programming problem and past allocation result data.

[0031] More specifically, for example, the information processing device 101 extracts terms containing only variables included in the subproblems from the remaining constraint equations. Next, the information processing device 101 identifies the values of each extracted term by referring to past allocation result data. Then, the information processing device 101 creates a second constraint equation including each extracted term based on the values of each identified term.

[0032] 1, constraint equations for subproblems 110-1 and 110-2 are created based on a set of constraint equations 130 (original set of constraint equations) for the linear programming problem 110 and past allocation result data 140 for the variables included in the linear programming problem 110. Taking the subproblem 110-1 as an example, a first constraint equation 130-1 for the subproblem 110-1 is created by extracting, from the set of constraint equations 130 for the linear programming problem 110, constraint equations that are true only for the variables included in the subproblem 110-1. Furthermore, a second constraint equation 130-2 for the subproblem 110-1 is created based on the remaining constraint equations, excluding the first constraint equation 130-1, from the set of constraint equations 130 for the linear programming problem 110 and the past allocation result data 140.

[0033] (4) The information processing device 101 finds a solution to the linear programming problem by sequentially solving each subproblem based on the objective function and constraint equations created for each subproblem. Specifically, for example, the information processing device 101 uses an existing solver (linear programming solver) to sequentially solve the subproblems based on the objective function and constraint equations of the subproblems.

[0034] In this case, the information processing device 101 creates constraint equations for all variables, where "variable = value of solution result", based on the solution result of the subproblem, and adds these as constraint equations for the other subproblems. Fixing some of the variables included in the subproblems to the solutions already found reduces the problem size of the subproblems. In this way, the information processing device 101 finds a solution to the linear programming problem by solving each subproblem in order.

[0035] In the example of FIG. 1, a solution to the linear programming problem 110 is obtained by solving each of the subproblems 110-1 and 110-2 in turn using an existing solver.

[0036] In this way, the information processing device 101 can divide the linear programming problem to be solved into subproblems and solve them. Also, the information processing device 101 can extract constraints to be applied to the subproblems from past allocation result data, thereby obtaining a solution (approximate solution) that satisfies the constraints for the entire problem within an allowable time.

[0037] This makes it possible to shorten the time required to solve the linear programming problem while achieving highly accurate shift allocation for nurses, operators, etc. In the example of Figure 1, by dividing the linear programming problem 110 to be solved into subproblems 110-1 and 110-2 and solving them, a solution that satisfies the constraints of the entire problem can be obtained within a time that is acceptable to the user.

[0038] (System configuration example of information processing system 200) Next, a system configuration example of an information processing system 200 including the information processing device 101 shown in Fig. 1 will be described. Here, an example will be described in which the information processing device 101 shown in Fig. 1 is applied to a solution-finding processing device 201 in the information processing system 200. The information processing system 200 is applied to a service that automates the allocation of resources such as people and things, for example.

[0039] Fig. 2 is an explanatory diagram showing an example of the system configuration of an information processing system 200. In Fig. 2, the information processing system 200 includes a solution-finding processing device 201 and a user terminal 202. In the information processing system 200, the solution-finding processing device 201 and the user terminal 202 are connected via a wired or wireless network 210. The network 210 is, for example, the Internet, a LAN (Local Area Network), or a WAN (Wide Area Network).

[0040] Here, the solution-finding processing device 201 is a computer that has a past case DB (Database) 220 and finds a solution to the linear programming problem to be solved. The solution-finding processing device 201 is realized by, for example, a server. However, the solution-finding processing device 201 may also be realized by a PC (Personal Computer).

[0041] The past case DB 220 stores past allocation result data. The allocation result data indicates the allocation results of resources such as people and things. For example, the allocation result data indicates the allocation results of nurse shifts in a hospital or the allocation results of operating rooms. The contents stored in the past case DB 220 will be described later using FIG. 4. A specific example of a linear programming problem to be solved will be described later using FIG. 5.

[0042] The user terminal 202 is a computer used by a user of the information processing system 200. The user terminal 202 is, for example, a PC, a tablet PC, etc. On the user terminal 202, the user can obtain the solution result of the linear programming problem by, for example, specifying the linear programming problem to be solved to the solution processing device 201.

[0043] The information processing system 200 may include, for example, a plurality of user terminals 202. The solution-finding processing device 201 may be realized by, for example, a plurality of computers. The solution-finding processing device 201 may be realized by, for example, the user terminal 202. The past case DB 220 may be held by another computer accessible to the solution-finding processing device 201. In this case, the solution-finding processing device 201 can refer to the past case DB 220 via the other computer.

[0044] (Example of hardware configuration of solution-finding processing device 201) Fig. 3 is a block diagram showing an example of the hardware configuration of the solution-finding processing device 201. In Fig. 3, the solution-finding processing device 201 has a CPU (Central Processing Unit) 301, a memory 302, a disk drive 303, a disk 304, a communication I / F (Interface) 305, a portable recording medium I / F 306, and a portable recording medium 307. Furthermore, each component is connected to each other by a bus 300.

[0045] Here, the CPU 301 is responsible for overall control of the solution-finding processing device 201. The CPU 301 may have multiple cores. The memory 302 includes, for example, a read-only memory (ROM), a random access memory (RAM), and a flash ROM. Specifically, for example, the flash ROM stores an OS program, the ROM stores application programs, and the RAM is used as a work area for the CPU 301. The programs stored in the memory 302 are loaded into the CPU 301, causing the CPU 301 to execute the coded processes.

[0046] The disk drive 303 controls reading / writing of data from / to the disk 304 under the control of the CPU 301. The disk 304 stores data written under the control of the disk drive 303. Examples of the disk 304 include a magnetic disk and an optical disk.

[0047] The communication I / F 305 is connected to the network 210 via a communication line, and is connected to an external computer (for example, the user terminal 202 shown in FIG. 2) via the network 210. The communication I / F 305 serves as an interface between the network 210 and the inside of the device, and controls the input and output of data from the external computer. For example, a modem or a LAN adapter can be used as the communication I / F 305.

[0048] Portable recording medium I / F 306 controls reading / writing of data from / to portable recording medium 307 under the control of CPU 301. Portable recording medium 307 stores data written under the control of portable recording medium I / F 306. Examples of portable recording medium 307 include a CD (Compact Disc)-ROM, a DVD (Digital Versatile Disk), and a USB (Universal Serial Bus) memory.

[0049] The solution-finding processing device 201 may have, for example, an input device, a display, etc. in addition to the above-mentioned components. The user terminal 202 shown in Fig. 2 can also be realized with the same hardware configuration as the solution-finding processing device 201. However, the user terminal 202 has, for example, an input device, a display, etc. in addition to the above-mentioned components.

[0050] (Stored contents of past case DB220) Next, we will explain the contents stored in the past case DB 220 of the solution-finding processing device 201. The past case DB 220 is realized by a storage device such as the memory 302 and the disk 304 shown in FIG.

[0051] Fig. 4 is an explanatory diagram showing an example of the contents stored in past case DB 220. In Fig. 4, past case DB 220 stores past case data (for example, past case data 400-1 to 400-3). The past case data indicates past allocation results. The past allocation results indicate, for example, manual allocation results. However, the past allocation results may indicate results of automatic allocation using any allocation algorithm, or may be results of automatic allocation that have been manually corrected.

[0052] For example, past case data 400-1 shows the assignment result (0 or 1) of shift X for each day (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday) for four weeks. An assignment result of "0" indicates that no shift has been assigned. An assignment result of "1" indicates that a shift has been assigned.

[0053] X is the name of the nurse. The pattern indicates the working hours. Pattern 1 indicates the day shift. Pattern 2 indicates the night shift. Pattern 3 indicates the late-night shift. For example, taking the first Sunday as an example, this indicates that X has been assigned a pattern 3 shift. Also, taking the second Sunday as an example, this indicates that X has been assigned a pattern 2 shift.

[0054] (Specific example of a linear programming problem to be solved) Next, a specific example of a linear programming problem to be solved will be described with reference to FIG.

[0055] Fig. 5 is an explanatory diagram showing a specific example of a linear programming problem to be solved. In Fig. 5, linear programming problem 500 is a problem for allocating shifts to nurses (X, Y, Z, ...) for each day (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday) for four weeks. However, Fig. 5 shows a group of elements of linear programming problem 500.

[0056] In the linear programming problem 500, for example, vX1, vX2, ..., vX66 are variables that indicate the results of the X shift allocation for each day. Also, vY1, vY2, ..., vY66 are variables that indicate the results of the Y shift allocation for each day. Also, vZ1, vZ2, ..., vZ66 are variables that indicate the results of the Z shift allocation for each day.

[0057] 4 corresponds to information indicating past allocation results for variables (for example, vX1, vX2, . . . ) included in the linear programming problem 500.

[0058] (Example of functional configuration of solution-finding processing device 201) Fig. 6 is a block diagram showing an example of the functional configuration of the solution-finding processing device 201. In Fig. 6, the solution-finding processing device 201 includes a receiving unit 601, a determining unit 602, a dividing unit 603, a solution-finding unit 604, and an output unit 605. The receiving unit 601 to the output unit 605 function as a control unit, and specifically, their functions are realized by causing the CPU 301 to execute a program stored in a storage device such as the memory 302, the disk 304, or the portable recording medium 307 shown in Fig. 3, or by the communication I / F 305. The processing results of each functional unit are stored in a storage device such as the memory 302 or the disk 304.

[0059] The receiving unit 601 receives an input of a linear programming problem to be solved. The linear programming problem includes an objective function and a set of constraint equations. Specifically, for example, the receiving unit 601 receives target problem information from the user terminal 202 shown in FIG. 2 , thereby receiving an input of the linear programming problem included in the received target problem information.

[0060] Here, the target problem information includes the linear programming problem to be solved (for example, the linear programming problem 500 shown in FIG. 5) and the allowable time t limit Allowable time t limit is the allowable time required to solve the linear programming problem to be solved. The accepting unit 601 may accept an input of the linear programming problem to be solved by operating an input device (not shown).

[0061] The receiving unit 601 may also receive a designation of a problem ID of a linear programming problem to be solved. In this case, the receiving unit 601 may receive an input of the linear programming problem to be solved by extracting the linear programming problem with the designated problem ID from a problem DB (not shown).

[0062] The determination unit 602 determines the allowable time t limit The division granularity of the linear programming problem is determined based on the above. The division granularity is the unit for dividing the linear programming problem into subproblems. The allowable time t limit is included in the target problem information, for example.

[0063] Specifically, for example, the determination unit 602 determines the problem size of the linear programming problem and the allowable time t limit and based on the allowable size d max Search for the allowable size d max is the allowable time t limit In this case, the determination unit 602 determines the maximum problem size d based on a prediction model that indicates the correspondence between problem size and solution time, for example, by using a binary search algorithm. max Then, the determining unit 602 may determine the searched allowable size d max Based on this, the division granularity of the linear programming problem is determined.

[0064] In the following explanation, the linear programming problem to be solved may be referred to as the "original problem." Note that the allowable size d max A search example will be described later with reference to FIGS.

[0065] Furthermore, when the problem size of the original problem is determined by days, the determining unit 602 may determine the division granularity to be either a week or a month. Specifically, for example, the dividing unit 603 may determine whether the problem size in weekly (or monthly) units is within the allowable size d max In the following cases, the division granularity is determined to be weekly (or monthly).

[0066] The dividing unit 603 divides the original problem based on the determined division granularity. Dividing the original problem corresponds to creating subproblems (objective functions, constraint equations) from the original problem so as to reduce the number of elements. Specifically, for example, the dividing unit 603 includes a first creating unit 606 and a second creating unit 607.

[0067] The first creating unit 606 creates objective functions for each of the subproblems divided from the original problem based on the determined division granularity, from the objective function of the original problem. Specifically, for example, the first creating unit 606 extracts variables corresponding to each subproblem from the original problem.

[0068] For example, when the original problem is divided by a period (number of days), the variables corresponding to each subproblem are variables included in the period corresponding to each subproblem. Then, the first creating unit 606 creates the objective function for each subproblem by removing variables different from the extracted variables from the objective function of the original problem.

[0069] As an example, let's say the original problem is "linear programming problem 500," and the objective function of original problem 500 is "min(sum(all variables on Sunday))=min(vX1+vX2+vX3+...+vX64+vX65+...)." This objective function is set, for example, to avoid scheduling shifts on Sundays as much as possible (minimize the number of assignments). Also, let's say the variables included in a certain subproblem are "vX1, vX2, vX3."

[0070] In this case, the first creation unit 606 creates an objective function for the subproblem by removing variables different from the variables vX1, vX2, and vX3 from the objective function of the original problem 500, "min(sum(all variables on Sunday))=min(vX1+vX2+vX3+...+vX64+vX65+...)". Here, the objective function for the subproblem becomes "min(sum(all variables on Sunday in the period))=min(vX1+vX2+vX3)". The period is the period corresponding to the subproblem (for example, the first week).

[0071] In the following explanation, the subproblems divided from the original problem are referred to as "subproblems P1 to P k " (k: a natural number greater than or equal to 1). Also, the subproblems P1 to P k Any subproblem of the i " (i=1,2,...,k).

[0072] The second creation unit 607 creates subproblems P1 to P2 based on the constraint equations of the original problem and past allocation result data for the variables included in the original problem. k Each subproblem P iThe constraint equation is created. The past assignment result data for the variables included in the original problem is the past assignment result data corresponding to the original problem. The past assignment result data corresponding to the original problem indicates, for example, the shift assignment results for the same period (number of days) and the same person as in the original problem.

[0073] The past allocation result data may be specified, for example, together with the original problem (the linear programming problem to be solved) in the target problem information. The second creation unit 607 may also search for past case data showing shift allocation results for the same period (number of days) and the same person as those in the original problem, by referring to the past case DB 220 shown in FIG. 4, for example. If the original problem is "linear programming problem 500," the past allocation result data for the variables included in the original problem is, for example, past case data 400-1 shown in FIG. 4.

[0074] Specifically, for example, the second creating unit 607 creates a set of constraints for each subproblem P i By extracting constraints that are true only for variables included in each subproblem P i As a result, the second creation unit 607 creates the first constraint equation of the subproblem P i Extract the constraints related to

[0075] As an example, the original problem is assumed to be a "linear programming problem 500," and the constraints of the original problem 500 are Constraint 1 "vX1+vY1+vZ1=1" and Constraint 2 "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3." Constraint 1 is assumed to be an equation that holds true only for variables that appear in subproblem P1. Constraint 2 is assumed to be an equation that includes variables that are not included in subproblem P1. In this case, the second creation unit 607 creates a first constraint for subproblem P1 by extracting Constraint 1, which holds true only for variables included in subproblem P1, from Constraints 1 and 2.

[0076] The second creating unit 607 creates a set of constraints for each subproblem P based on the remaining constraints excluding the first constraint among the constraints of the original problem and the past allocation result data.i More specifically, for example, the second creation unit 607 creates a second constraint equation of the subproblem P i Extract terms containing only variables included in

[0077] Next, the second creating unit 607 refers to past allocation result data and identifies the value of each extracted term. Then, the second creating unit 607 creates a second constraint equation including each extracted term based on the identified value of each term. An example of dividing the original problem (linear programming problem to be solved) will be described later with reference to FIG. 9. Also, the subproblem P i An example of creating this constraint equation (second constraint equation) will be described later with reference to FIGS.

[0078] The solving unit 604 solves partial problems P1 to P k Each subproblem P i Based on the objective function and constraints created for each subproblem P i Specifically, for example, the solution-finding unit 604 uses an existing solver (linear programming solver) to solve the created subproblem P i Based on the objective function and constraints of i Solve the following.

[0079] Next, the solution unit 604 solves the subproblem P i Based on the solution result, create a constraint equation for all variables, "variable = solution result value", and i+1 In this way, the subproblem P i+1 By fixing some of the variables in i+1 The problem size becomes smaller.

[0080] Then, the solution-finding unit 604 uses an existing solver to solve the created subproblem P i+1 The objective function and constraints of the subproblem P i (including the constraints added based on the solution results of i+1 In this way, the solution unit 604 solves the subproblems P1 to Pk The solution to the original problem is obtained by solving the above equations in order. A specific example of the solution-finding process for finding the solution to the original problem will be described later with reference to Figures 14A and 14B.

[0081] The output unit 605 outputs the solution result. Here, the solution result indicates a solution to the original problem. However, there are cases where a solution cannot be obtained. In such cases, the solution result indicates that there is no solution. The output format of the output unit 605 can be, for example, storage in a storage device such as the memory 302 or the disk 304, transmission to another computer (for example, the user terminal 202) via the communication I / F 305, display on a display (not shown), or printout on a printer (not shown).

[0082] The functional units of the solution-finding processing device 201 described above may be realized by, for example, a plurality of computers (for example, the solution-finding processing device 201, the user terminal 202) in the information processing system 200.

[0083] (allowable size d max (Example of search) Next, using Figs. 7 and 8, the allowable size d max An example of searching for the above will be described.

[0084] Fig. 7 is an explanatory diagram showing the correspondence relationship between problem size and solution time. In Fig. 7, graph 700 shows the increase in solution time for a linear programming problem as problem size increases. Graph 700 corresponds to a prediction model showing the correspondence relationship between problem size and solution time.

[0085] The determination unit 602 may refer to the graph 700 to determine the allowable time t limit While changing the problem size, the solution time is limit The allowable size d is within max (Maximum problem size) is found using binary search.

[0086] Here, using a specific example of a prediction model, the allowable size d maxHere, we will explain an example of calculating the number of shifts for nurses. The problem size of the original problem is set to "20 people, 30 days." By dividing the original problem by days (number of days), we can calculate the number of partial problems P1 to P2. k Assume that the data is divided into

[0087] Fig. 8 is an explanatory diagram showing a specific example of a prediction model. In Fig. 8, table 800 is an example of a prediction model showing the correspondence between problem size (number of days) and solution time (total calculation time). Table 800 is, for example, generated in advance and stored in a storage device such as memory 302 or disk 304.

[0088] In table 800, the total calculation time (maximum value) indicates the time (maximum value) required to assign 20 people to shifts when the original problem is divided into problems for each number of days (unit: seconds). The calculation time and required number of runs indicate the time required to solve each subproblem and the number of runs required to solve the problem when the original problem is divided into problems for each number of days. The total calculation time (maximum value) is calculated by multiplying the calculation time by the required number of runs.

[0089] Here, the allowable time t limit "t limit = 1800 seconds". In this case, the determining unit 602 first sets the unit of days to be divided to "30 days" and identifies the total calculation time "24201" by referring to the table 800 (step 0 of the search). Here, the total calculation time "24201" is set to the allowable time t limit It exceeds that.

[0090] Therefore, the determining unit 602 calculates the number of days to be examined next (problem size) so that the problem size becomes smaller. Here, the number of days to be examined next is "number of days to be examined next = 30 - {(30 - 0) / 2} = 15". In this case, the determining unit 602 sets the unit of days to be divided to "15 days" and identifies the total calculation time "311" by referring to the table 800 (step 1 of search). Here, the total calculation time "311" is within the allowable time t limit It is inside.

[0091] Therefore, the determining unit 602 calculates the number of days to be examined next so that the problem size becomes larger. In this case, the number of days to be examined next is "number of days to be examined next = 15 + {(22 - 15) / 2} = 19 (rounded to the nearest whole number)". In this case, the determining unit 602 sets the unit of days to be divided to "19 days" and identifies the total calculation time "1195" by referring to the table 800 (step 3 of the search). Here, the total calculation time "1195" is within the allowable time t limit It is inside.

[0092] Therefore, the determining unit 602 calculates the number of days to be examined next so that the problem size becomes larger. Here, the number of days to be examined next is "number of days to be examined next = 19 + {(22 - 19) / 2} = 21 (rounded to the nearest whole number)". In this case, the determining unit 602 sets the unit of days to be divided to "21 days" and identifies the total calculation time "2342" by referring to the table 800 (step 4 of the search). Here, the total calculation time "2342" is within the allowable time t limit It exceeds that.

[0093] Therefore, the determining unit 602 calculates the number of days to be examined next so as to reduce the problem size. Here, the number of days to be examined next is "number of days to be examined next = 21 - {(21 - 19) / 2} = 20". In this case, the determining unit 602 sets the unit of days to be divided to "20 days" and identifies the total calculation time "1673" by referring to the table 800 (step 5 of the search). Here, the total calculation time "1673" is within the allowable time t limit It is inside.

[0094] Also, when the number of days to be divided is "21 days", the total calculation time "2342" is the allowable time t limit Therefore, the determining unit 602 determines the allowable size d max Here, the case where the original problem is divided by days (number of days) has been described as an example, but the present invention is not limited to this. For example, the determination unit 602 determines the allowable size d max may be determined.

[0095] (Example of splitting the original problem) Next, an example of dividing the original problem (linear programming problem to be solved) will be described with reference to FIG. 9. Here, the linear programming problem 500 shown in FIG. 5 will be used as an example of the original problem. Also, the problem size of the original problem 500 is set to "16 people, 28 days", and the original problem 500 is divided by days (number of days) to create subproblems P1 to P2. k Assume that the data is divided into

[0096] FIG. 9 is an explanatory diagram showing an example of dividing the original problem. Here, the allowable size d max "d max = 8 days". Here, the question size of the original question 500 is determined by the date. Therefore, the determining unit 602 determines whether the question size is within the allowable size d max Divide the original problem 500 evenly into the standard size d by the week or month so that base Determine the reference size d base corresponds to the division granularity.

[0097] Here, the entire period d total is "d total = 28 days. Therefore, the standard size d base For example, the allowable size d max The following week unit "d base =7". In this case, each partial problem P i The problem size (days) is, for example, "i·d base " (i=1,2,...,d total / d base -1).

[0098] In the example of FIG. 9, the dividing unit 603 divides the determined reference size d base Based on this, for example, original question 500 is divided into sub-questions 901 to 903 by dividing it into units of weeks (7 days) from the beginning of original question 500. Sub-question 901 corresponds to the first week. Sub-question 902 corresponds to the first and second weeks. Sub-question 903 corresponds to the first to third weeks. Note that FIG. 9 shows an excerpt of each question.

[0099] The problem size of the subproblem 901 is "7 days". The problem size of the subproblem 902 is "14 days". The problem size of the subproblem 903 is "21 days". The solution-finding processor 201 solves the subproblems 901 to 903 in ascending order of problem size, for example. Note that if the problem sizes of the subproblems 902 and 903 are less than the allowable size d max However, since some variables become known during the solution process, the actual problem size is within the allowable size d max The following is the result.

[0100] (Partial problem P i (Example of creating a constraint expression) Next, using Figures 10 to 13, the subproblem P i An example of creating the constraint equation (second constraint equation) will be described below. Here, it is assumed that the original problem is a "linear programming problem 500" and that the original problem 500 is divided into subproblems 901 to 903 as shown in FIG.

[0101] Fig. 10 is an explanatory diagram showing an example of extracted allocation result data. Fig. 10 shows past case data 400-1. The past case data 400-1 shows past allocation results for variables included in the original question 500. Note that Fig. 10 shows an excerpt of part of the past case data 400-1.

[0102] In this case, the second creation unit 607 extracts, for example, past allocation result data corresponding to partial problem 901 (see FIG. 9 ) from the past case data 400-1. Here, partial problem 901 corresponds to the first week of original problem 500. Therefore, the second creation unit 607 extracts allocation result data 1001 for the first week from the past case data 400-1 as past allocation result data corresponding to partial problem 901. The allocation result data 1001 corresponds to the past shift allocation result for the same period and the same person as partial problem 901.

[0103] Furthermore, the second creation unit 607 extracts, for example, past assignment result data corresponding to partial problem 902 (see FIG. 9 ) from past case data 400-1. Here, partial problem 902 corresponds to the first and second weeks of original problem 500. Therefore, the second creation unit 607 extracts assignment result data 1002 for the first and second weeks from past case data 400-1 as past assignment result data corresponding to partial problem 902. The assignment result data 1002 corresponds to the past shift assignment result for the same person for the same period as partial problem 902.

[0104] Furthermore, the second creation unit 607 extracts, for example, past allocation result data corresponding to partial problem 903 (see FIG. 9 ) from past case data 400-1. Here, partial problem 903 corresponds to the first to third weeks of original problem 500. Therefore, the second creation unit 607 extracts allocation result data 1003 for the first to third weeks from past case data 400-1 as past allocation result data corresponding to partial problem 903. Allocation result data 1003 corresponds to past shift allocation results for the same person for the same period as partial problem 903.

[0105] 11 to 13 are explanatory diagrams showing examples of creating constraint equations for subproblems. In Fig. 11, a case where a constraint equation (second constraint equation) for subproblem 901 is created will be described. Here, the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" is one of the constraint equations for original problem 500, and is a constraint equation that also includes variables that are not included in subproblem 901.

[0106] In this case, the second creation unit 607 extracts only the terms of the variables "vX2, vX3" included in the subproblem 901 from the left side of the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" of the original problem 500, and creates a new constraint equation as shown in the following equation (1), where C1 is a variable.

[0107] vX2+vX3=C1 (1)

[0108] Next, the second creation unit 607 refers to the past allocation result data 1001 corresponding to the subproblem 901, and identifies the allocation results (values) for the variables vX2 and vX3 included in the above formula (1). Here, the allocation result "0" for the variable vX2 and the allocation result "1" for the variable vX3 are identified.

[0109] Then, the second creating unit 607 calculates the value of C1 by substituting the identified allocation result (value) into the left side of the above formula (1). Here, the value of C1 is "1." The second creating unit 607 creates a constraint equation such as the following formula (2) as a constraint equation (second constraint equation) for the subproblem 901 by substituting the calculated value of C1 into the above formula (1).

[0110] vX2+vX3=1 (2)

[0111] Here, the case where the constraint equation is expressed by an equality such as the above formula (1) has been described as an example, but the present invention is not limited to this. For example, the second creation unit 607 may create a new constraint equation expressed by an inequality such as the following formula (3) instead of the above formula (1). Here, C1 is a variable, and a is a constant.

[0112] C1-a≦vX2+vX3≦C1+a (3)

[0113] 12, a description will be given of a case where a constraint equation (second constraint equation) for subproblem 902 is created. Here, the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" is one of the constraint equations for original problem 500, and is a constraint equation that also includes variables that are not included in subproblem 902.

[0114] In this case, the second creation unit 607 extracts only the terms of the variables "vX2, vX3, vX23, vX24" included in the subproblem 902 from the left side of the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" of the original problem 500, and creates a new constraint equation as shown in the following equation (4), where C2 is a variable.

[0115] vX2+vX3+vX23+vX24=C2 (4)

[0116] Next, the second creation unit 607 refers to the past allocation result data 1002 corresponding to the subproblem 902, and identifies allocation results (values) for the same variables as the variables vX2, vX3, vX23, and vX24 included in the above formula (4). Here, the allocation result "0" for the variable vX2, the allocation result "1" for the variable vX3, the allocation result "1" for the variable vX23, and the allocation result "0" for the variable vX24 are identified.

[0117] Then, the second creation unit 607 calculates the value of C2 by substituting the identified allocation result (value) into the left side of the above formula (4). Here, the value of C2 is "2." The second creation unit 607 creates a constraint equation such as the following formula (5) as a constraint equation (second constraint equation) for the subproblem 902 by substituting the calculated value of C2 into the above formula (4).

[0118] vX2+vX3+vX23+vX24=2 (5)

[0119] 13, a description will be given of the creation of a constraint equation (second constraint equation) for subproblem 903. Here, the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" is one of the constraint equations for original problem 500, and is a constraint equation that also includes variables that are not included in subproblem 903.

[0120] In this case, the second creation unit 607 extracts only the terms of the variables "vX2, vX3, vX23, vX24, vX43, vX45" included in the subproblem 903 from the left side of the constraint equation "vX2+vX3+vX23+vX24+vX43+vX45+vX65+vX66≦3" of the original problem 500, and creates a new constraint equation as shown in the following equation (6), where C3 is a variable.

[0121] vX2+vX3+vX23+vX24+vX43+vX45=C3...(6)

[0122] Next, the second creation unit 607 refers to the past allocation result data 1003 corresponding to the subproblem 903, and identifies allocation results (values) for the same variables as the variables vX2, vX3, vX23, vX24, vX43, and vX45 included in the above formula (6). Here, the allocation result "0" for the variable vX2, the allocation result "1" for the variable vX3, the allocation result "1" for the variable vX23, the allocation result "0" for the variable vX24, the allocation result "1" for the variable vX43, and the allocation result "0" for the variable vX45 are identified.

[0123] Then, the second creation unit 607 calculates the value of C3 by substituting the identified allocation result (value) into the left side of the above formula (6). Here, the value of C3 is "3." The second creation unit 607 creates a constraint equation such as the following formula (7) as a constraint equation (second constraint equation) for the subproblem 903 by substituting the calculated value of C3 into the above formula (6).

[0124] vX2+vX3+vX23+vX24+vX43+vX45=3 ···(7)

[0125] (Example of solution process) A specific example of the solution-finding process for finding a solution to the original problem 500 will be described with reference to FIGS. 14A and 14B.

[0126] 14A and 14B are explanatory diagrams showing a specific example of the solution-finding process. In Fig. 14A, first, the solution-finding unit 604 uses an existing solver to solve the sub-problem 901 based on the objective function and constraint equations of the created sub-problem 901. As a result, a solution result 1401 is obtained. The solution result 1401 indicates the values of each variable included in the sub-problem 901.

[0127] Next, the solution finding unit 604 references the solution result 1401 and creates constraint equations of "variable = value of the solution result" for all variables included in the subproblem 901, and adds these as constraint equations for the subproblem 902. For example, suppose that the value of the solution result 1401 for the variable vX1 included in the subproblem 901 is "0." In this case, the solution finding unit 604 creates a constraint equation of "vX1=0" for the variable vX1 and adds this as a constraint equation for the subproblem 902.

[0128] In this way, by fixing some of the variables included in subproblem 902 with the already obtained solution, the problem size of subproblem 902 is reduced. Then, using an existing solver, solution finding unit 604 solves subproblem 902 based on the objective function and constraint equations (including the constraint equations added based on solution result 1401) of the created subproblem 902. As a result, solution result 1402 is obtained. Solution result 1402 indicates the values of each variable included in subproblem 902.

[0129] 14B, next, the solution finding unit 604 refers to the solution results 1401 and 1402, and creates constraint equations of "variable = value of the solution result" for all variables included in the subproblem 902, and adds these as constraint equations for the subproblem 903. However, the constraint equations for the variables included in the subproblem 901 may be ones that have already been created.

[0130] For example, suppose that the value of solution result 1402 for variable vX22 included in subproblem 902 is "0." In this case, solution finding unit 604 creates a constraint equation for variable vX22, "vX22=0," and adds it as a constraint equation for subproblem 903. In this way, by fixing some of the variables included in subproblem 903 at the solution that has already been found, the problem size of subproblem 903 is reduced.

[0131] Then, using an existing solver, the solution-finding unit 604 solves the created sub-problem 903 based on the objective function and constraint equations (including the constraint equations added based on the solution results 1401 and 1402) of the sub-problem 903. As a result, it is assumed that the solution result 1403 is obtained. The solution result 1403 indicates the values of each variable included in the sub-problem 903.

[0132] Next, solution-finding unit 604 refers to solution results 1401 to 1403, and creates constraint equations of "variable = value of solution result" for all variables included in subproblem 903, and adds these as constraint equations for original problem 500. However, constraint equations for variables included in subproblems 901 and 902 may be reused from those that have already been created.

[0133] For example, suppose that the value of solution result 1403 for variable vX43 included in subproblem 903 is "0." In this case, solution finding unit 604 creates a constraint equation "vX43=0" for variable vX43 and adds it as a constraint equation for original problem 500. In this way, by fixing some of the variables included in original problem 500 at the solutions that have already been found, the problem size of original problem 500 is reduced.

[0134] Then, using an existing solver, the solution finding unit 604 solves the original problem 500 based on the objective function and constraint equations (including constraint equations added based on the solution results 1401 to 1403) of the original problem 500. As a result, a final solution 1404 is obtained. The final solution 1404 is a solution to the original problem 500, and indicates the values of each variable included in the original problem 500.

[0135] (Procedure of allocation process of solution-finding processor 201) Next, the allocation processing procedure of the solution-finding processing device 201 will be described with reference to FIG.

[0136] Fig. 15 is a flowchart showing an example of the allocation processing procedure of the solution-finding processing device 201. In Fig. 15, the solution-finding processing device 201 determines whether or not target problem information has been received (step S1501). Here, the solution-finding processing device 201 waits until it receives target problem information (step S1501: No).

[0137] When the solution-finding processor 201 receives the target problem information (step S1501: Yes), it executes an allowable size search process (step S1502). The specific processing procedure of the allowable size search process will be described later with reference to FIG.

[0138] Next, the solution-finding processing device 201 executes a problem division process for the linear programming problem to be solved (original problem) (step S1503). The specific processing procedure for the problem division process will be described later with reference to FIG. 17. Then, the solution-finding processing device 201 executes a rule extraction process for the subproblems (step S1504). The specific processing procedure for the rule extraction process will be described later with reference to FIG. 18.

[0139] Next, the solution finding processing device 201 executes a solution finding process for the linear programming problem to be solved (step S1505). The specific processing steps of the solution finding process will be described later with reference to Fig. 19. Then, the solution finding processing device 201 outputs the solution result for the linear programming problem to be solved (step S1506), and ends the series of processes according to this flowchart.

[0140] This allows the solution-finding processor 201 to obtain a solution that satisfies the constraints throughout the problem within a time that is acceptable to the user.

[0141] Next, a specific processing procedure for the allowable size search processing in step S1502 shown in FIG. 15 will be described with reference to FIG.

[0142] 16 is a flowchart showing an example of a specific processing procedure for the allowable size search process. In the flowchart of FIG. 16, first, the solution-finding processor 201 uses a binary search algorithm to find the allowable size d from the problem size of the linear programming problem and the prediction model. max is searched for (step S1601).

[0143] Then, the solution-finding processor 201 calculates the allowable size d max (step S1602), and returns to the step that called the allowable size search process. limit It is possible to find the maximum problem size that can be solved within a certain time.

[0144] Next, the specific processing procedure of the problem division process in step S1503 shown in Fig. 15 will be explained using Fig. 17. Here, the problem size of the original problem (linear programming problem to be processed) is determined by the date, and the original problem is divided by the period (number of days). max corresponds to the solvable period, for example.

[0145] 17 is a flowchart showing an example of a specific processing procedure for dividing a problem. In the flowchart of FIG. 17, first, the solution-finding processing device 201 calculates the allowable size d max From the original problem, the base size d base is determined (step S1701). base For example, the allowable size d max The following is in units of weeks or months.

[0146] Then, the solution-finding processor 201 calculates the determined reference size d base Based on this, k periods T{t1, t2, ..., tk} are set (step S1702). For example, k is expressed as "k=d total / d base " d total indicates the entire period of the original problem. The period ti is from day 1 to i·d base The period from the first to the second (i=1,2,...,k).

[0147] Next, the solution-finding processing device 201 sets "i=1" (step S1703) and extracts variables included in the period ti from the original problem (step S1704). Then, the solution-finding processing device 201 removes out-of-range variables from the objective function of the original problem to create a new objective function (step S1705). The out-of-range variables are variables different from the variables extracted in step S1704.

[0148] Next, the solution-finding processing device 201 removes constraints that include variables outside the range from the set of constraints of the original problem, and creates new constraints (step S1706). Then, the solution-finding processing device 201 applies the created objective function and constraints to the subproblem P i (step S1707).

[0149] Next, the solution-finding processing device 201 sets "i = i + 1" (step S1708) and determines whether i is greater than k (step S1709). If i is equal to or less than k (step S1709: No), the solution-finding processing device 201 returns to step S1704. On the other hand, if i is greater than k (step S1709: Yes), the solution-finding processing device 201 returns to the step that called the problem division process.

[0150] This gives the reference size d base Based on the (partition granularity), the original problem (the linear programming problem to be solved) is divided into subproblems P1 to P2 for each period t1 to tk. k can be divided into

[0151] Next, a specific processing procedure for the rule extraction processing in step S1504 shown in FIG. 15 will be described with reference to FIG.

[0152] 18 is a flowchart showing an example of a specific processing procedure of the rule extraction process. In the flowchart of FIG. 18, first, the solution-finding processor 201 sets "i=1" (step S1801), and extracts a subproblem P from the remaining constraint equations of the constraint equation group of the original problem, excluding the constraint equation created in step S1706 shown in FIG. i Constraint expressions including variables included in (step S1802).

[0153] Next, the solution-finding processing device 201 selects unselected constraint equations from the extracted constraint equations (step S1803). Then, the solution-finding processing device 201 finds a subproblem P from the selected constraint equations. i (Step S1804) Next, the solution-finding processor 201 creates new constraint equations including the remaining terms, with reference to past allocation result data.

[0154] Then, the solution-finding processor 201 converts the created constraint equations into a subproblem P i (step S1806). Next, the solution finding processing device 201 determines whether or not there are any unselected constraint equations among the extracted constraint equations (step S1807). If there are any unselected constraint equations (step S1807: Yes), the solution finding processing device 201 returns to step S1803.

[0155] On the other hand, if there are no unselected constraint equations (step S1807: No), the solution finding processing device 201 sets "i = i + 1" (step S1808) and determines whether i is greater than k (step S1809). If i is less than or equal to k (step S1809: No), the solution finding processing device 201 returns to step S1802. On the other hand, if i is greater than k (step S1809: Yes), the solution finding processing device 201 returns to the step that called the rule extraction process.

[0156] This allows us to use past allocation result data to calculate each subproblem P i A constraint equation (second constraint equation) can be created.

[0157] Next, a specific processing procedure of the solution-finding process in step S1505 shown in FIG. 15 will be described with reference to FIG.

[0158] 19 is a flowchart showing an example of a specific processing procedure for the solution-finding process. In the flowchart of FIG. 19, first, the solution-finding processing device 201 sets "i=1" (step S1901), and solves the subproblems P1 to P2 using a linear programming solver. k Partial problem P of i is solved (step S1902).

[0159] Then, the solution-finding processing device 201 determines whether or not a solution has been found (step S1903). If a solution has not been found (step S1903: No), the solution-finding processing device 201 proceeds to step S1910. On the other hand, if a solution has been found (step S1903: Yes), the solution-finding processing device 201 i Based on the solution results, new constraint equations are created for all variables, where "variable = value of solution result" (step S1904).

[0160] Then, the solution-finding processor 201 converts the created constraint equations into a subproblem P i+1 (or the original problem) as a constraint equation (step S1905). Next, the solution finding processor 201 sets "i=i+1" (step S1906) and determines whether i is greater than k (step S1907).

[0161] If i is equal to or less than k (step S1907: No), the solution-finding processing device 201 returns to step S1902. On the other hand, if i is greater than k (step S1907: Yes), the solution-finding processing device 201 uses a linear programming solver to solve the original problem (step S1908).

[0162] The solution-finding processing device 201 then determines whether or not a solution has been found (step S1909). If a solution has been found (step S1909: Yes), the series of processes according to this flowchart ends. On the other hand, if a solution has not been found (step S1909: No), the solution-finding processing device 201 determines that there is no solution (step S1910) and returns to the step that called the solution-finding process.

[0163] As a result, the solution-finding processor 201 divides the original problem into subproblems P1 to P k The solution processing device 201 can divide the problem into subproblems P i By fixing some of the variables in i This reduces the problem size and shortens the time it takes to solve the original problem.

[0164] As described above, according to the solution-finding processing device 201 of the embodiment, the allowable time t limit Based on the original problem, the division granularity (base size d base ) can be determined. Furthermore, the solution-finding processor 201 determines the subproblems P1 to P2 divided from the original problem based on the determined division granularity. k Each subproblem P i The objective function of each subproblem P is created from the objective function of the original problem, and is calculated based on the constraints of the original problem and the past allocation result data for the variables included in the original problem. i Then, the solution processing device 201 creates the constraint equations for each subproblem P i Based on the objective function and constraints created for each subproblem P i By solving these in order, the solution to the original problem can be found.

[0165] As a result, the solution-finding processor 201 divides the original problem into subproblems P1 to P k By dividing the problem into parts and solving them, the time required to solve the original problem can be shortened, and a solution that satisfies the constraints of the entire problem can be obtained within a time that is acceptable to the user.

[0166] Furthermore, according to the solution-finding processing device 201, among the constraint equation group of the original problem, each subproblem P i By extracting constraints that are true only for variables included in each subproblem P i Furthermore, the solution-finding processor 201 can generate a first constraint equation for each subproblem P based on the remaining constraint equations excluding the first constraint equation from the group of constraint equations of the original problem and the past allocation result data. i A second constraint can be created:

[0167] As a result, the solution-finding processor 201 solves the subproblem P i In creating the subproblem P, we reuse the constraints of the original problem. i For constraint expressions that include variables that do not appear in the previous table, values can be supplemented using past assignment results to create new constraint expressions.

[0168] Furthermore, according to the solution-finding processing device 201, the problem size of the original problem and the allowable time t limit and based on the allowable size d max Search for the allowable size d max Specifically, for example, the solution-finding processing device 201 uses a binary search algorithm to determine the allowable size d based on a prediction model that indicates the correspondence between problem size and solution time. max Explore.

[0169] As a result, the solution-finding processor 201 divides the problem into as large a problem size as possible so as not to decrease the probability that the final solution will satisfy the constraints, while keeping the allowable time t limit It is possible to determine the division granularity that will give a solution within the

[0170] Furthermore, according to the solution-finding processor 201, when the problem size of the original problem is determined by days, the division granularity can be set to either weekly or monthly units.

[0171] As a result, when the problem size is determined by the date, the problem size is often restricted by a week or a month. Therefore, by using the week or month as the division granularity, the solution-finding processing device 201 can i It is possible to create a constraint equation that is likely to lead to good results.

[0172] Furthermore, the solution-finding processor 201 can output the solution to the original problem.

[0173] As a result, the solution-finding processing device 201 can provide shift allocation results for nurses, operators, etc. (solutions to the linear programming problem to be solved).

[0174] From these facts, the solution-finding processing device 201 can obtain a solution that satisfies the constraints throughout the problem within a time that is acceptable to the user. This makes it possible to automate and reduce the labor required for allocation tasks that have previously been done manually, such as work schedules for shift workers (e.g., nurses, operators, etc.) and operating room usage schedules.

[0175] The solution-finding method described in this embodiment can be realized by executing a prepared program on a computer such as a personal computer or a workstation. This solution-finding program is recorded on a computer-readable recording medium such as a hard disk, flexible disk, CD-ROM, DVD, or USB memory, and is executed by being read from the recording medium by the computer. This solution-finding program may also be distributed via a network such as the Internet.

[0176] In addition, the information processing device 101 (solution-finding processing device 201) described in this embodiment can also be realized by an application-specific IC such as a standard cell or a structured ASIC (Application Specific Integrated Circuit) or a PLD (Programmable Logic Device) such as an FPGA.

[0177] The following additional notes are provided regarding the above-described embodiment.

[0178] (Supplementary Note 1) A division granularity for dividing a linear programming problem into a plurality of subproblems is determined based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating constraint equations for each of the subproblems based on a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function and the constraint equations created for each of the subproblems; An information processing device comprising a control unit that executes processing.

[0179] (Supplementary Note 2) The control unit creating a first constraint for each of the subproblems by extracting, from the group of constraints, a constraint that is satisfied only by variables included in each of the subproblems; generating second constraint equations for the respective subproblems based on the remaining constraint equations excluding the first constraint equation from the group of constraint equations and the past allocation result data; 2. The information processing device according to claim 1, wherein the information processing device executes a process.

[0180] (Supplementary Note 3) The control unit searching for a maximum problem size that can be solved within the allowed time based on the problem size of the linear programming problem and the allowed time; determining the division granularity based on the largest problem size found; 3. The information processing device according to claim 1 or 2, which executes processing.

[0181] (Supplementary Note 4) The control unit An information processing device according to claim 3, characterized in that it executes a process of searching for the maximum problem size that can be solved within the allowable time based on a model showing the correspondence between problem size and solution time using a binary search algorithm.

[0182] (Supplementary Note 5) The control unit 5. The information processing device according to claim 3, wherein when the problem size of the linear programming problem is determined by a date, the division granularity is set to either a week or a month.

[0183] (Supplementary Note 6) The control unit The information processing device according to any one of appendices 1 to 5, wherein for each of the subproblems, an objective function for each of the subproblems is created by removing variables different from variables included in the subproblem from the objective function of the linear programming problem.

[0184] (Supplementary Note 7) The control unit 7. The information processing device according to any one of Supplementary Notes 1 to 6, wherein a solution to the linear programming problem is output.

[0185] (Appendix 8) determining a division granularity for dividing the linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating constraint equations for each of the subproblems based on a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function and the constraint equations created for each of the subproblems; A solution-finding method characterized in that the processing is executed by a computer.

[0186] (Appendix 9) determining a division granularity for dividing a linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating constraint equations for each of the subproblems based on a group of constraint equations for the linear programming problem and past allocation result data for variables included in the linear programming problem; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function and the constraint equations created for each of the subproblems; A solution-finding program that causes a computer to execute a process. [Explanation of symbols]

[0187] 101 Information processing equipment 110,500 Linear Programming Problems 120 Objective Function 130 Constraint Expressions 140,1001,1002,1003 Allocation result data 200 Information Processing Systems 201 Solution Processing Device 202 User terminal 210 Network 220 Past case DB 300 Bus 301 CPU 302 memory 303 Disk Drive 304 Disk 305 Communication I / F 306 Portable Recording Media I / F 307 Portable Recording Media 601 Reception 602 Decision Section 603 Split section 604 Solving section 605 Output section 606 First Creation Section 607 Second Creation Division 700 graphs 800 tables 901,902,903 Partial problems 1401,1402,1403 Solution result 1404 Final solution

Claims

1. determining a division granularity for dividing the linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating a first constraint equation for each of the subproblems by extracting a constraint equation that is satisfied only by variables included in each of the subproblems from a group of constraint equations for the linear programming problem; extracting terms containing only variables included in each of the subproblems from the remaining constraint equations excluding the first constraint equation from the group of constraint equations; Identifying the value of each extracted term by referring to past allocation result data for variables included in the linear programming problem; creating second constraint equations for the respective subproblems, including the extracted terms, based on the identified values of the terms; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function, the first constraint equation, and the second constraint equation, which are created for each of the subproblems; An information processing device comprising a control unit that executes processing.

2. The control unit searching for a maximum problem size that can be solved within the allowed time based on the problem size of the linear programming problem and the allowed time; determining the division granularity based on the largest problem size found; 2. The information processing apparatus according to claim 1, wherein the information processing apparatus executes processing.

3. The control unit 3. The information processing apparatus according to claim 2, wherein when the problem size of the linear programming problem is determined by a date, the division granularity is set to a unit of either a week or a month.

4. The control unit 4. The information processing apparatus according to claim 1, wherein a solution to the linear programming problem is output.

5. determining a division granularity for dividing a linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating a first constraint equation for each of the subproblems by extracting a constraint equation that is satisfied only by variables included in each of the subproblems from a group of constraint equations for the linear programming problem; extracting terms containing only variables included in each of the subproblems from the remaining constraint equations excluding the first constraint equation from the group of constraint equations; Identifying the value of each extracted term by referring to past allocation result data for variables included in the linear programming problem; creating second constraint equations for the respective subproblems, including the extracted terms, based on the identified values of the terms; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function, the first constraint equation, and the second constraint equation, which are created for each of the subproblems; A solution-finding method characterized in that the processing is executed by a computer.

6. determining a division granularity when dividing a linear programming problem into a plurality of subproblems based on an allowable time required for solving the linear programming problem to be solved; creating objective functions for each of the subproblems divided from the linear programming problem based on the determined division granularity from the objective function of the linear programming problem; creating a first constraint equation for each of the subproblems by extracting a constraint equation that is satisfied only by variables included in each of the subproblems from a group of constraint equations for the linear programming problem; extracting terms containing only variables included in each of the subproblems from the remaining constraint equations excluding the first constraint equation from the group of constraint equations; Identifying the value of each extracted term by referring to past allocation result data for variables included in the linear programming problem; creating second constraint equations for the respective subproblems, including the extracted terms, based on the identified values of the terms; obtaining a solution to the linear programming problem by sequentially solving each of the subproblems based on the objective function, the first constraint equation, and the second constraint equation, which are created for each of the subproblems; A solution-finding program that causes a computer to execute a process.

Images