Building construction resource constraint allocation optimization method based on big data

Abstract

The invention discloses a building construction resource constraint allocation optimization method based on big data, particularly relates to the field of building engineering resource management, and is used for solving the problems of on-duty waiting, equipment idling, channel congestion and scheduling and field rhythm departure caused by the fact that material in-place, working plane admission, channel release and mutual exclusion control are not synchronously met in the existing scheduling. Reading an operation window through a unified time mark, and subscribing a material in-place event to generate a time anchor point; according to anchor point extraction constraint fragments, transcription channel release records and mutual exclusion rules, forming a constraint fragment set for a working plane admission condition; constructing a resource feasible region, and executing a four-state closed decision to screen candidate time periods and output an initial allocation table; checking the initial distribution table in a landing manner, marking mismatch and writing the mismatch back to the constraint fragment set; and according to mismatch, triggering rolling recalculation, retaining a local rearrangement non-executed segment of the main closed segment, outputting a stable distribution table, and solidifying criterion reference.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of construction engineering resource management, and more particularly, to a construction resource constraint allocation optimization method based on big data. BACKGROUND

[0002] The construction organization is connected with the plan, modeling and material links through a unified time scale, the progress platform divides the work window and issues the input arrangement of the team and the equipment, the building information modeling platform records the components, the process and the mutual exclusion relationship, the material platform synchronizes the on-site, inspection, warehousing, distribution and in-place state, the on-site access control and channel record the track of entering and occupying. The resource allocation optimization is mainly driven by the work window, and it is expected that under the constraints of the release criterion and the empty criterion, the continuous input and output of personnel, equipment and materials are realized according to the queue state, forming a complete link from arrival, entry, work to evacuation.

[0003] However, when the work window is regarded as a time period that can be directly executed, the material in-place, work face access, channel release and mutual exclusion control cannot be satisfied at the same time, and the resource scheduling appears to be on duty waiting and equipment idling at the starting point of the window; When the access is limited, the release criterion cannot be triggered, and the empty criterion is mispositioned, so that the subsequent scheduling and the field rhythm deviate; The cross-area migration of shared equipment is delayed because the channel and the procedure link are not mapped as execution conditions; The material arrival only stays in the state record and is not converted into the available condition of entering the work face, so the carrying and in-place lag invade the limited channel and work face capacity, causing queuing congestion in the field; The cross-operation mutual exclusion and safety distance in the building information modeling platform are not converted into the work face capacity, and the actual execution cannot be carried out simultaneously after the scheduling superimposes multiple tasks on the same work face.

[0004] In order to solve the above problems, a technical scheme is provided. SUMMARY

[0005] In order to overcome the above-mentioned defects of the prior art, the embodiments of the present application provide a construction resource constraint allocation optimization method based on big data, which converts the channel release record and the mutual exclusion rule into executable constraint fragments by anchoring the work window and the material in-place event under a unified time scale, and generates a single access result by closing the four states of reachability, accessibility, workability and retreatability, while eliminating the execution fragmentation by merging the short-time yielding gap through bridge inspection, and then performs local rolling rearrangement through landing check and mismatch backwriting to keep the main closed segment stable, thereby solving the problems raised in the background art.

[0006] To achieve the above object, the present application provides the following technical scheme: S1: read the work window under a unified time scale and subscribe to the material in-place event, generate the work window table and the in-place event stream as the time anchor point of the execution judgment; S2: Extract executable constraint segments from the job window table and the just-in-time event stream, and convert the channel release records and the mutual exclusion rules into job face access conditions to obtain a constraint segment set; S3: Construct a resource feasible domain from the constraint segment set, perform a four-state closed decision at the access decision point, filter the team and equipment candidate time periods according to the synchronization and continuity of reachability, accessibility, workability and retreatability, and output an initial allocation table; S4: Perform landing verification on the initial allocation table using the access records, lifting trajectories and progress logs, and mark and write back the constraint segment set for segments that do not meet the release criteria and emptying criteria; S5: Trigger a rolling recalculation according to the mismatch mark, rearrange and replace the unexecuted segments on the premise of retaining the main closed segments, output a stable allocation table, and solidify the reference relationship of the release criteria and the emptying criteria.

[0007] Further, step S1 reads job window data from the progress platform to generate a job window table, subscribes to just-in-time events from the material platform to generate a just-in-time event stream, and aligns the job window table and the just-in-time event stream with a unified time scale to perform anchor verification, forming a time anchor for execution decision.

[0008] Further, step S2 parses the channel available time period sequence and the entry and exit order from the channel release records, parses the conflicting task pairs and the safety distance requirement from the mutual exclusion rules, and extracts the preliminary constraint segment list by cutting the channel available time period sequence and the mutual exclusion rules according to the start time and end time of the job window table.

[0009] Further, step S2 binds the material just-in-time dependency from the just-in-time event stream to the preliminary constraint segment list to generate a bound constraint segment list, each bound constraint segment is extended to include the dependency trigger time and the material identifier, and the bound constraint segment list is mapped one-to-one with the job window table to generate a constraint segment set.

[0010] Further, step S3 groups the constraint segment set according to the window sequence number of the job window table to establish a resource feasible domain, forms a time domain grid for each job window, and generates a four-state Boolean sequence based on the channel release records to determine the reachability state, based on the job face access conditions to determine the accessibility state, based on the job window table and the mutual exclusion rules to determine the workability state, and based on the emptying criteria and the retreat rules to determine the retreatability state. Form a closed segment set by searching for continuous time periods that satisfy the four-state true at the same time from the four-state Boolean sequence, perform bridge connection verification on adjacent closed segments in the closed segment set, and merge into a bridge connected closed segment set if the start and end sequences are consistent and the entry and exit conditions are continuous.

[0011] Further, step S3 selects the start time of the start point of the bridging closed section set and the end point of the emptying requirement as the starting time of the operation window table and the main closed section, generates the closed state result, including full closed, half closed and lost closed types, and for the main closed section of the full closed type, maps the main closed section start time, main closed section end time, operation face identification, task type and four-state reference to the team candidate and equipment candidate to form the allocation entry, for the half closed, retains the allocation entry of the main closed section and generates a replacement request for the tail section, and for the lost closed, removes the window entry and writes the bridging closed section set to the constraint segment set, and writes the initial allocation table.

[0012] Further, step S4 loads the access track data from the access record to form the access track data set, loads the material movement log from the hoisting track to form the hoisting track data set, and loads the operation execution record from the progress log to form the progress log data set, checks the entry time and release criterion from the access track data set and the hoisting track data set for each main closed section in the initial allocation table, calculates the entry deviation and release state, checks the operation start time and exit completion time from the progress log data set and the access track data set, calculates the operation deviation and exit deviation, forms the extended check result set, and each main closed section contains the deviation value and the check state.

[0013] Further, step S4 according to the extended check result set, labels the main closed section that does not meet the release criterion as reachable mismatch, labels the main closed section that does not meet the access condition as accessible mismatch, labels the main closed section that is in operation conflict as operable mismatch, and labels the main closed section that does not meet the emptying criterion as exitable mismatch, adds the restriction description to the corresponding segment of the constraint segment set with the main closed section start and end time and mismatch type as the key, updates the constraint segment set to expand the mismatch field and persists to the database.

[0014] Further, step S5 reads the mismatch label from the constraint segment set to form the mismatch segment list, identifies the unexecuted segment subset according to the mismatch segment list and the initial allocation table and isolates the main closed section set, generates the replacement candidate segment sequence from the constraint segment set and the in-place event stream, performs local rearrangement on the replacement candidate segment sequence to form the temporary rearrangement chain, verifies that the reachable state, the accessible state, the operable state and the exitable state of all nodes in the temporary rearrangement chain are true and the order is continuous, and outputs the rearranged segment chain that passes the verification.

[0015] Further, step S5 replaces the unexecuted segment subset with the optimal item of the rearranged segment chain and concatenates it with the isolated main closed section set to generate the stable allocation table, extracts the four-state reference and the restriction description from the stable allocation table entry to generate the reference key-value pair, associates the reference key-value pair with the replacement period to form the trace chain and archives it to the audit log, and each audit log contains the window serial number, the reference key-value pair and the constraint segment number, which serves as the traceable execution basis.

[0016] The technical effect and advantages of the building construction resource constraint allocation optimization method based on big data are as follows: The application anchors the job window and the material positioning event under the unified time scale, converts the channel release and mutual exclusion rules into executable constraint fragments, generates a single access result through four-state closed decision making of reachability, accessibility, workability and retreatability, eliminates execution fragmentation by merging short-time release gaps through bridge connection inspection, and then performs local rolling rearrangement through landing verification and mismatch backwrite traction, so as to keep the main closed segment stable. Thus, the allocation result, the release criterion, the emptying criterion and the queue state are semantically connected, the resource allocation and the job rhythm form a continuous link, the on-site waiting and the equipment idling are reduced, the channel occupation and congestion are relieved, the consistency, predictability and traceability of progress execution are strengthened, thereby providing stable support for the on-site landing of resource constraint allocation. BRIEF DESCRIPTION OF DRAWINGS

[0017] Figure 1 The flowchart of the building construction resource constraint allocation optimization method based on big data is shown. DETAILED DESCRIPTION

[0018] The technical solutions in the embodiments of the application will be clearly and completely described below with reference to the drawings in the embodiments of the application. Obviously, the described embodiments are only part of the embodiments of the application, rather than all the embodiments. Based on the embodiments in the application, all other embodiments obtained by those skilled in the art without creative labor fall within the scope of the application.

[0019] Embodiment 1: Figure 1 The building construction resource constraint allocation optimization method based on big data is given, including: S1 reads the job window under the unified time scale and subscribes to the material positioning event, generates a job window table and a positioning event stream as time anchor points for execution decision.

[0020] S2 extracts executable constraint fragments according to the job window table and the positioning event stream, converts the channel release record and the mutual exclusion rule into job surface access conditions to obtain a constraint fragment set.

[0021] S3 constructs a resource feasible region with the constraint fragment set, performs four-state closed decision making at the access decision point, filters the team and equipment candidate time period according to the synchronous and coherent reachability, accessibility, workability and retreatability, and outputs an initial allocation table.

[0022] S4 performs landing verification on the initial allocation table using the access record, hoisting trajectory and progress log, and annotates and writes back the constraint fragment set for the fragments that do not meet the release criterion and the emptying criterion.

[0023] S5 triggers rolling recalculation based on mismatch annotations, performs partial rearrangement and replacement on unexecuted segments while preserving the main closed segment, outputs a stable allocation table and solidifies the reference relationship between release criteria and empty criteria.

[0024] In the construction resource constraint allocation optimization method, the construction organization divides the work window through the progress platform and issues the input arrangement of teams and equipment, and the material platform synchronizes the arrival, inspection, storage, distribution and positioning of materials to realize the complete link of resources from arrival, entry, work to evacuation. However, existing resource scheduling often fails to meet the material positioning, work face access, channel release and mutual exclusion control at the same time, resulting in on-site waiting, equipment idling and deviation of subsequent scheduling and site rhythm. To solve this problem, step S1 generates a work window table and a positioning event stream as a time anchor for execution judgment by reading the work window under a unified time scale and subscribing to material positioning events, thereby providing accurate time boundaries and event trigger basis for subsequent constraint extraction and feasible region construction, ensuring that the criteria for resource allocation and the site state remain synchronized and connected, and avoiding execution deviation caused by parameter drift.

[0025] Step S1.1 reads the work window data from the progress platform. The progress platform stores the work window information in the construction organization plan, including the start time, end time and associated work face identifier and task type of each window. From the progress platform interface call reading instruction, for the preset construction project identifier, all work window original data records are extracted one by one. Specifically, for each work window, record its start time (unit in UTC timestamp of unified time scale, indicating the exact time when the plan starts to execute), end time (unit in UTC timestamp of unified time scale, indicating the exact time when the plan ends), work face identifier (string form, used to uniquely identify the associated physical work area, such as "floor 3A area") and task type (enum value, such as "concrete pouring" or "reinforcement binding", used for subsequent constraint mapping). The reading process adopts batch query mode, first establishes a connection session with the progress platform, then filters all unexecuted windows under the current project through SQL-like query statements, ensures data integrity through checksum and verification, and temporarily stores in the memory buffer. The output of this step is an unformatted work window original data set, which is directly input to generate the work window table.

[0027] Step S1.2 subscribes to the material platform positioning event stream.

[0028] The material platform maintains a change log of the state of the material from arrival to placement, including inspection, warehousing, distribution, and triggering events of completion of placement. A subscription request is initiated from the event subscription interface of the material platform, and a filter condition for listening to the material placement event is specified, that is, only change notifications with a state of "placement completion" are captured. Specifically, for each placement event, the occurrence time (unit: UTC timestamp of unified time scale, indicating the completion time when the material is handed over), material identification (string form, used to uniquely identify a specific material batch, such as "steel bar batch M-001"), associated work surface identification (consistent with step S1.1, used to match work windows), and placement state (boolean value, fixed as true, indicating availability). The subscription adopts a real-time streaming push mechanism, and after establishing a persistent connection, the notification is received through an event queue buffer, and the JSON format payload of each event is parsed immediately upon arrival to ensure that the event sequence is accumulated in chronological order. The output of this step is a real-time updated placement event original sequence, which is directly input to generate the placement event stream.

[0029] Step S1.3 generates a work window table structure.

[0030] Based on the work window original data set output in step S1.1, a structured work window table is constructed. The table adopts a relational data format, with each row corresponding to a work window, and the columns include start time , end time , work surface identification , and task type . The generation process first sorts the original data set in ascending order of start time , then traverses each row of data, verifies whether the time interval meets the preset minimum work duration threshold (for example, no less than 30 minutes to exclude invalid windows), and marks and excludes those that do not meet the threshold. Next, index columns are added to the table, including window number (auto-incrementing integer starting from 1) and time hash value (MD5 digest based on and for fast retrieval). Finally, the formatted table is persisted in a local database or in-memory table as a time boundary reference on the planning side. This step ensures that the work window table becomes the only time anchor input for constraint segment extraction in subsequent step S2.

[0031] Step S1.4 generates a placement event stream sequence.

[0032] Based on the placement event original sequence output in step S1.2, an ordered placement event stream is constructed. The stream adopts a time series data format, with each item corresponding to a placement event, and the attributes include occurrence time Material identification Related work surface identification and in place The generation process first filters out duplicates from the original sequence, then sorts them by material identifier. Check for duplicate events and keep only the most recent one. Then press Sort the events in ascending order to form a continuous chain. When traversing the sequence, for each event, perform an association check. If the event matches the job face identifier in the job window table of step S1.3, a dependency tag (a boolean value indicating the binding relationship with the window) is added; otherwise, it is marked as an isolated event and temporarily stored in the standby queue. Finally, the ordered stream is serialized and saved as a subscribing stream object as a dynamic trigger reference for material availability. This step outputs the in-place event stream, ensuring that it is aligned with the timescale of the job window table, providing an event anchor point for the material in-place dependency mapping in step S2.

[0033] Step S1.5 Unify time scale alignment and anchor point verification.

[0034] The job window table generated in step S1.3 and the in-place event stream generated in step S1.4 are aligned and verified under a unified time scale. The unified time scale refers to the global UTC time base, ensuring that all time attributes (such as...) are aligned. , , All are converted to this baseline. The processing traverses each window in the job window table, querying the in-place event stream. Falling All events within the interval, if a match exists Then, inject the event reference list (containing matching events) into the corresponding row of the job window table. and (Array); if no match is found, an empty list is injected and a potential delay warning is recorded. Verification uses a time window intersection algorithm, that is, for each window, the coverage ratio is calculated. The numerator is the sum of the durations of the matched events (assuming each event lasts a fixed number of units of time), and the denominator is the window duration, ensuring... If the value exceeds the preset standard, the anchor point is marked as valid; otherwise, an alarm is triggered but generation is not interrupted. Finally, the aligned job window table and the in-place event stream are output as the dual anchor point set for execution determination. Upon completion of this step, all anchor point data maintain consistent parameter definitions, facilitating step S2's extraction of executable constraint fragments based on the job window table and the in-place event stream.

[0035] Step S1 establishes the time basis for resource allocation optimization by reading job window data from the schedule platform, subscribing to material platform position event, generating job window table and position event stream, and performing uniform time scale alignment and anchor point verification. In this way, the start-up waiting and equipment idling risks of the job window are eliminated, because the job window table provides accurate planning boundaries, and the position event stream captures the actual available completion time of the material. After alignment, the anchor point set ensures that the material dependency and channel release conditions are not misaligned due to time scale drift when extracting subsequent constraint segments, thereby laying a traceable execution semantic support for the entire resource continuous input and output link, improving the consistency of the schedule platform and the material platform, and avoiding the potential risk of shared equipment migration delay and on-site congestion.

[0036] Step S1 has generated job window table and position event stream as time anchor points for execution judgment, ensuring time scale alignment of schedule platform and material platform, thereby providing accurate boundaries for resource continuous input and output link. However, existing constraint processing often leads to unsynchronized mapping of material position dependency and entry-exit order within the job window due to the fact that channel release records and mutual exclusion rules are not parsed and transcribed into job surface access conditions, thereby causing execution fragmentation of resource scheduling and channel congestion. To overcome this defect, step S2 extracts executable constraint segments based on job window table and position event stream, transcribes channel release records and mutual exclusion rules into job surface access conditions, and generates constraint segment set, thereby providing uniform condition input for subsequent resource feasible region construction, avoiding criterion deviation caused by mixed use of multiple sets of expressions, and ensuring access consistency of shift and equipment input.

[0037] Step S2.1 parses channel release records to generate available time period sequence.

[0038] Channel release records store the entry-exit log of on-site access control and channels, including release time, channel identifier and order information. From the channel release record database interface call read instruction, for the job surface identifier of the job window table in step S1, extract all original logs of associated channels. Specifically, for each channel release event, record its release time (unit: UTC timestamp of uniform time scale, representing the accurate time of channel opening), channel identifier (string form, used to uniquely identify physical channels, such as "East Channel C-01") and entry-exit order (integer value, representing the order of events in the channel, such as 1 for the first release). The parsing process first filters the logs under the current project, according to Sort in ascending order, then apply a time-merge algorithm (for merging overlapping or adjacent open intervals) to the consecutive release events, i.e. if the end time of an adjacent event is within a pre-defined threshold (e.g. 5 minutes) from the start time of the next one, merge them into a single available period. The output is a sequence of channel available periods, each containing the start release time , the end release time , the channel identifier and the cumulative order (based on the cumulative value, representing the total number of entries in the period), as preliminary input for the access condition of the transcription job face.

[0039] Step S2.2 parses the exclusion rules to extract safety distance requirements.

[0040] The exclusion rules are derived from the building information modeling platform, defining the task conflict and distance specifications on the same job face. From the exclusion rule knowledge base interface call to read instructions, for the task type and job face identifier of the job window table, extract all related rule entries. Specifically, for each exclusion rule, record its applicable task type , conflict task type (enumerated value, indicating the tasks that are prohibited from being parallel, such as "pouring" and "welding"), safety distance requirement (float number, unit: meter, representing the minimum physical separation distance, such as 2.5 meters) and exclusion duration (unit: minutes, representing the duration of the conflict state). The parsing process traverses the rule set, groups the same rules, then applies rule priority sorting (based on descending order ), and eliminates redundant rules (if the and of two rules are the same and the is smaller, the larger one is covered). The output is an exclusion rule extraction set, each containing the job face identifier , the conflict task pair , the safety distance requirement and the exclusion duration , as a supplementary input for the access condition of the transcription job face.

[0041] Step S2.3 divides the constraint segment according to the job window time scale.

[0042] According to the job window table generated in step S1, the channel available period sequence of step S2.1 and the exclusion rule extraction set of step S2.2 are divided according to the time scale of the job window. Specifically, for each window of the job window table, the start time and the end time ​As a split boundary, the query channel available period sequence is partitioned into and while the query mutual exclusion rule extracts a rule subset matching . The split process adopts interval intersection calculation (for finding the overlapping part of window and available period), i.e. for each matching period, the intersection start time and the intersection end time are calculated, if then a preliminary constraint segment is formed; then the mutual exclusion rule is incorporated, if there is a conflicting task pair in the intersection, then is subtracted from . The output is a preliminary constraint segment list, each item containing start and end time , channel identifier , order , conflicting task pair and safety distance requirement , as intermediate data for binding material placement dependency.

[0043] Step S2.4 binds material placement dependency to constraint segment.

[0044] For the preliminary constraint segment list of step S2.3, material placement dependency is injected from the placement event stream of step S1. Specifically, for the start and end time and job face identifier of each preliminary constraint segment, the query is made for matching events in the placement event stream and , if there is, the earliest is selected as the dependency trigger time , and the associated material identifier is recorded. The binding process checks dependency satisfaction: if , the segment status is marked as dependency satisfied; otherwise, postpone to , and verify that the adjusted does not exceed the of the job window table. If there is no matching event, an empty dependency mark (indicating no material constraint) is added. The output is a bound constraint segment list, each item extended to contain start and end time , channel identifier , order , conflicting task pair , safety distance requirement , dependency trigger time and material identifier , as preparation data for establishing one-to-one mapping.

[0045] Step S2.5 establishes one-to-one mapping to generate constraint segment set.

[0046] The post-binding constraint segment list of step S2.4 is one-to-one mapped with the job window table to form the final constraint segment set. Specifically, for each window of the job window table, the post-binding constraint segment list is traversed to match segments overlapping with the time period, sorted in ascending order and associated one by one: the first segment is mapped to the start of the window, and the subsequent segments are sequentially mapped to the remaining interval, and if the interval is not covered, an empty segment is added (start and end time are the remaining interval, and the constraint is marked as none). The mapping process uses a hash table for storage, with the window number of the job window table as the key and the associated segment array as the value, ensuring that each window has at most one primary segment and a sequence of auxiliary segments. Finally, all mapping results are aggregated into a constraint segment set, each containing complete start and end times , bound job face access conditions (channel identifier , order , conflicting task pairs , safety distance requirements ), material placement dependencies (dependency trigger time , material identifier ), and window mapping references (window sequence number). This set is persisted in memory or a database as the only input for step S3 to build the resource feasible domain.

[0047] Step S2 generates the available time period sequence by parsing the channel release record, extracts safety distance requirements by parsing mutual exclusion rules, divides constraint segments according to job window time stamps, binds material placement dependencies, and establishes one-to-one mapping to generate the constraint segment set, achieving the transcription and synchronization of channel and mutual exclusion conditions. In the construction scene, this resolves the lag problem of material arrival state not being transcribed into job face availability conditions, as the constraint segment set maps the order of entry and exit, safety distance, and placement events to the job window boundaries, ensuring that the access conditions are not mixed in the subsequent four-state closed decision, thereby eliminating the lag of shared equipment moving across segments and the mutual exclusion conflict of multiple tasks on the same job face, improving the continuity of resource deployment and the utilization efficiency of channel capacity, and providing a solid constraint basis for the predictability of the site rhythm.

[0048] Step S2 extracts executable constraint fragments based on the work window table and the in-place event flow, transcribes the channel release records and mutual exclusion rules into work surface access conditions, and generates a constraint fragment set. This provides a unified condition expression for resource access, avoiding criterion bias caused by the mixing of multiple expressions. However, existing resource scheduling often ignores the synchronous continuity of the four-state execution status, resulting in the inability to simultaneously satisfy the reachable, enterable, workable, and exitable states within the work window. This leads to fragmentation in the selection of candidate time slots for work teams and equipment, as well as semantic disconnect between the initial allocation table and the release and clearing criteria. To fill this gap, step S3 constructs a resource feasible domain using the constraint fragment set, executes a four-state closed-loop decision at the access decision point, selects candidate time slots for work teams and equipment based on the synchronous continuity of reachable, enterable, workable, and exitable states, and outputs an initial allocation table. This ensures the continuity of resource input and the orderliness of exit, eliminating the risk of waiting and idle time on the execution side and channel delays.

[0049] Step S3.1 Establish the resource feasible region based on the constraint fragment set.

[0050] The constraint fragment set contains start and end times, job entry conditions, material placement dependencies, and window mapping references, serving as the foundation for constructing the resource feasible domain. All fragments are loaded from the in-memory storage of the constraint fragment set and grouped according to the window index in the job window table, forming a subset of fragments corresponding to each job window. Specifically, for each group, the start and end times in the constraint fragment set are traversed. and inject channel identifiers ,order Conflict missions Safety distance requirements Dependence on trigger time Material identification Construct a two-dimensional time-domain structure: the horizontal axis is the time axis (from the job window table). to The vertical axis represents the state dimension (channel, admission, mutual exclusion, dependency). The establishment process employs a grid-filling algorithm (used to expand discrete fragments into continuous feasible intervals), that is, for each fragment... to Fill in the available markers; if conflicting task pairs exist, mark the occupied bits in that interval. The output is a resource feasible region, with each item corresponding to a time-domain grid of a job window, containing the filled available intervals and occupied bits, serving as the input basis for the four-state judgment.

[0051] Step S3.2: Determine the four-state execution state and generate a state sequence.

[0052] On the temporal grid of the resource feasible domain, synchronous judgments are performed according to four execution states: reachable, enterable, operable, and regressable, generating a state sequence. First, the available time period sequence of the channel is extracted from the channel release record. and First, the intersection with the current grid interval of the resource feasible region; if the overlap length is greater than zero, the reachable state is marked as true. Second, the job face admission conditions (channel identifiers) are based on the constraint fragment set. With order ), check if the entry and exit order is satisfied within the grid interval, if the order A continuously increasing increment indicates an "entry-ready" status as true; furthermore, this is based on the task type in the job window table. Conflicts with mutual exclusion rules Safety distance requirements Verify that there are no overlapping conflicts within the grid interval. If the spacing between all task pairs exceeds [a certain value], [the following will occur]. Then the flag can be set to true; finally, based on the clearing criterion (predefined exit rules, such as the exit completion time must be earlier than the next window), The system uses exit rules (thresholds for access control exit logs) to predict the feasibility of exiting at the end of a grid interval. If the conditions are met, the exitable state is marked as true. The judgment process evaluates each grid time point point by point, forming a four-state Boolean sequence (reachable sequence, enterable sequence, workable sequence, exitable sequence), which serves as the input for the search of continuous time periods.

[0053] Step S3.3: Search for continuous time periods to form a closed segment set.

[0054] For each job window's time-domain grid within the feasible resource domain, a set of closed segments is formed by searching the state sequence generated in step S3.2 for consecutive time intervals where all four states are true. Specifically, the four-state Boolean sequence is traversed, and a continuous subarray summation algorithm (finding the fully true subsequence) is used. That is, the interval is expanded one by one from the grid's starting point until any point where the state is false is encountered, forming candidate closed segments. For each candidate closed segment, its starting time is calculated. (The moment of the first full-scale point) and the end moment (The moment of the last full truth point), and verify. The job window table and If the verification passes, the segment is added to the set of closed segments. Each closed segment contains... Related work surface identification It uses four-state references (state sequence fragments). The search process is executed sequentially in time, ensuring no overlap between segments, and outputs a closed set of segments as input for bridging tests.

[0055] The continuous subarray summation algorithm is a dynamic programming technique used to find the continuous subarray with the largest sum in a given one-dimensional array. It achieves an optimized solution with O(n) time complexity by scanning element by element and maintaining the maximum sum of the current subarray and the global maximum sum.

[0056] Step S3.4 performs a bridge check to merge bridge closed segments.

[0057] The adjacent closed segments in the closed segment set formed in step S3.3 are subjected to a bridge check, and if the start-end sequence consistency and the continuous entry-exit condition are met, they are merged into a bridge closed segment. Specifically, the sorted closed segment set is checked in pairs in ascending order: the gap length is calculated , and if is less than a preset yielding threshold (for example, 10 minutes, indicating temporary yielding or temporary occupation), the start-end sequence consistency (the channel identifier of the previous segment is the same as that of the subsequent segment ) and the continuous entry-exit condition (the exit state reference of the previous segment can be connected to the accessible state reference of the subsequent segment without interruption ) are checked; if both conditions are met, the previous segment is merged into the subsequent segment , and the four-state reference is updated to a spliced sequence. The check uses a chain verification algorithm (for recursive merging of adjacent chains), and the process is repeated until there is no gap to merge. The output is a bridge closed segment set, each containing the merged , channel identifier , order , and four-state splicing reference, which serves as input for selecting the main closed segment. The chain verification algorithm is a recursive chain merging mechanism specifically designed to handle the continuity check and fusion of adjacent data segments. In the context of resource allocation optimization, it is applied to bridge checks to eliminate temporary gaps. Specifically, the algorithm first performs a linear traversal of the sorted closed segment set, and evaluates the gap length between adjacent segments in pairs. If the gap is less than a preset threshold, the chain condition check is triggered, including start-end sequence consistency (verifying whether the channel identifier at the end of the previous segment is the same as the channel identifier at the start of the subsequent segment) and entry-exit condition continuity (confirming that the order of the exit state reference of the previous segment and the accessible state reference of the subsequent segment is uninterrupted). If the conditions are met, the start time of the previous segment and the end time of the subsequent segment are spliced into a new chain segment by recursive call, and the four-state reference sequence is updated to a continuous splicing form. This process continues until there is no remaining gap to merge. The time complexity of this algorithm is O(n), where n is the number of closed segments, ensuring efficient processing of temporarily occupied adjacent segments, achieving fragmentation elimination and overall coherence maintenance of the executed link, thereby providing a stable bridge closed segment set basis for subsequent main closed segment selection.

[0058] The chain verification algorithm is a recursive chain merging mechanism specifically designed to handle the continuity check and fusion of adjacent data segments. In the context of resource allocation optimization, it is applied to bridge checks to eliminate temporary gaps. Specifically, the algorithm first performs a linear traversal of the sorted closed segment set, and evaluates the gap length between adjacent segments in pairs. If the gap is less than a preset threshold, the chain condition check is triggered, including start-end sequence consistency (verifying whether the channel identifier at the end of the previous segment is the same as the channel identifier at the start of the subsequent segment) and entry-exit condition continuity (confirming that the order of the exit state reference of the previous segment and the accessible state reference of the subsequent segment is uninterrupted). If the conditions are met, the start time of the previous segment and the end time of the subsequent segment are spliced into a new chain segment by recursive call, and the four-state reference sequence is updated to a continuous splicing form. This process continues until there is no remaining gap to merge. The time complexity of this algorithm is O(n), where n is the number of closed segments, ensuring efficient processing of temporarily occupied adjacent segments, achieving fragmentation elimination and overall coherence maintenance of the executed link, thereby providing a stable bridge closed segment set basis for subsequent main closed segment selection.

[0059] Step S3.5 selects the main closed segment to generate the closed state result.

[0060] ​Select the start sticking operation window and the end covering empty requirement from the bridge closure segment set in step S3.4 to generate the closure state result. Specifically, for each bridge closure segment, calculate the start sticking degree (the absolute difference, indicating the deviation from the start time of the operation window), and the end covering degree (if positive, it covers the empty requirement); preferentially select the segment with the smallest and as the main closure segment, and if there is no such segment, select the one with the smallest as the main closure segment and mark the tail segment as unclosed. The generation process traverses all bridge closure segments and evaluates the closure state: if the main closure segment covers the entire , it is a full closure; if it covers part of it and the tail segment can be replaced, it is a semi-closure; if there is no main closure segment, it is a loss closure. Output the closure state result, which includes the main closure segment , closure type (full closure, semi-closure, loss closure) and replacement request (if semi-closed, specify the start and end of the tail segment) as the basis for the initial allocation table output.

[0061] Step S3.6 writes the initial allocation table according to the closure state.

[0062] According to the closure state result in step S3.5, filter the team and equipment candidate time periods and write them into the initial allocation table. Specifically, for the main closure segment of the full closure, directly map , the associated operation face identifier , task type and four-state reference to team candidates (matching group in the preset team library) and equipment candidates (matching device ID with channel identifier ), forming an allocation entry; for semi-closure, only keep the allocation entry of the main closure segment and generate a replacement request for the tail segment (including the unclosed interval and material positioning dependency ); for loss closure, remove the entry for this window and write the bridge closure segment set back to the constraint segment set (add a loss closure marker). The writing process uses a relational table structure, and the initial allocation table columns include window number, team ID, equipment ID, time period , release criterion reference (based on reachable state) and emptying criterion reference (based on retractable state), ensuring the same semantics. Finally, persist the initial allocation table to the database as input for step S4 landing review.

[0063] Step S3 realizes the synchronous and coherent screening of admission decision by establishing the resource feasible domain based on the constraint segment set, generating the state sequence by judging the four-state execution status, forming the closed segment set by searching the continuous time period, merging the bridging closed segment by performing the bridging inspection, generating the closed state result by selecting the main closed segment, and writing the initial allocation table according to the closed state. Thus, the problem of superimposed conflict of work face capacity not converted into calculable mutual exclusion is solved, because the four-state closed decision relies on the transcription of channel release record and mutual exclusion rule, ensuring that the candidate time period in the initial allocation table covers the full link from achievable to retreatable, thereby reducing the risk that the actual execution of multiple tasks in the same work face cannot be simultaneously expanded, improving the prediction consistency of the team and equipment investment and the continuous utilization of channel resources, and providing single admission result support without weight for subsequent landing verification.

[0064] Step S3 has constructed the resource feasible domain with the constraint segment set, screened the team and equipment candidate time period through the four-state closed decision, and output the initial allocation table, ensuring the same semantics of release criterion and empty criterion, thereby providing single admission result for the continuous link of resource investment. However, the existing initial allocation table often deviates from the actual situation due to the actual deviation of the site access record, hoisting trajectory and progress log, resulting in the inability to verify the entry time of the closed segment, the starting point of the work and the completion time of the exit, and further causing the mismatch problem of release failure or exit blockage, causing the deviation of subsequent scheduling and site rhythm. To make up for this deficiency, step S4 uses the access record and hoisting trajectory and progress log to perform landing verification on the initial allocation table, annotates and writes back the constraint segment set for the segments that do not meet the release criterion and empty criterion, thereby dragging the rolling recalculation through the mismatch write-back mechanism, ensuring that the constraint segment set directly quotes the site trajectory, avoiding repeated conflict triggering, and improving the execution traceability of resource allocation.

[0065] Step S4.1 calls the access record to load the in-out trajectory data.

[0066] The access record stores the in-out log of the site personnel and equipment, including the timestamp and identification information. The read instruction is called from the access record database interface, and all associated in-out trajectories are extracted for the window number and work face identification of the initial allocation table . Specifically, for each access event, the entry time (unit: UTC timestamp of unified time scale, representing the actual entry time into the work face), exit time (unit: UTC timestamp of unified time scale, representing the actual exit time from the work face), team ID (string form, used to match the team candidate of the initial allocation table) and equipment ID (string form, used to match the equipment candidate of the initial allocation table) are recorded. The loading process uses time range query to filter the log according to the time period of the initial allocation table , establishes a connection session first and then pulls the data in batches, ensuring that the trajectory sequence is in chronological order sorted in ascending order. This step outputs the access trajectory dataset, each entry contains , , team ID and equipment ID as the input source to verify the entry time.

[0067] Step S4.2 calls the lifting trajectory to load the material movement log.

[0068] The lifting trajectory records the on-site movement path of the material from distribution to in-place, including lifting time and location information. The read instruction is called from the lifting trajectory log interface, and all related movement events are extracted for the material identifier and the work surface identifier of the initial allocation table. Specifically, for each lifting event, record its lifting start time (unit: UTC timestamp of unified time scale, indicating the time when the material lifting starts), lifting end time (unit: UTC timestamp of unified time scale, indicating the time when the material is in place), and trajectory position (coordinate pair, indicating the path point from the distribution point to the work surface). The loading process uses the event subscription mode to filter the trajectories under the current project, and after sorting by , the path continuity checking algorithm (used to verify the continuous connection between trajectory points, and marked as valid if there is no interruption) is applied, and invalid trajectories are removed. The output is the lifting trajectory dataset, each entry contains , , material identifier and trajectory position, which are used as input sources to verify the work start time.

[0069] Step S4.3 calls the progress log to load the work execution record.

[0070] The progress log maintains the actual execution status of the on-site task, including the start and completion time. The read instruction is called from the progress log platform interface, and all matching execution records are extracted for the task type and window number of the initial allocation table. Specifically, for each progress event, record its work start time (unit: UTC timestamp of unified time scale, indicating the time when the actual task starts), completion time (unit: UTC timestamp of unified time scale, indicating the time when the task ends and is cleared), and mutual conflict flag (Boolean value, indicating whether the safety interval requirement is violated). The loading process traverses the log file, groups by work surface identifier , and then applies the time alignment algorithm (used to calibrate the log timestamp with the unified time scale) to the event sequence to ensure that the deviation is less than 1 second. The output is the progress log dataset, each entry contains , Task Type Mutual exclusion conflict markers serve as the input source for verifying the completion time of the exit.

[0071] Step S4.4: Verify the entry time and release criteria segment by segment.

[0072] For each main closed segment in the initial allocation table, the entry time and release criteria are checked segment by segment from the access control trajectory dataset in step S4.1 and the hoisting trajectory dataset in step S4.2. Specifically, for the main closed segment... Query the access control trajectory to match the work group ID and the device ID. If the earliest The release criterion is then met; simultaneously, the material identifier is matched in the hoisting trajectory. of ,like The material release is then satisfied. The verification process uses a parallel comparison algorithm (used to simultaneously verify personnel, equipment, and material trajectories). If any... or If the deviation exceeds a preset tolerance threshold (e.g., 5 minutes), it is marked as a release failure. The output is a verification result set, with each main closure segment extension including the entry deviation. (Time difference, representing the deviation between the actual and the planned) and release status (satisfied or failed) serve as the basis for subsequent reachability mismatch annotation.

[0073] Step S4.5: Verify the start point and exit completion time of each segment of the operation.

[0074] Continue by checking the start point and exit completion time of each main closed segment in the initial allocation table, segment by segment, using the progress log dataset from step S4.3 and the access control trajectory dataset from step S4.1. Specifically, for each main closed segment... and Query the progress log to match the task type of ,like and If the deviation is within the tolerance range and the mutual exclusion conflict is marked as false, then the operation start point satisfies the condition; query the access control trajectory. If all The exit condition is then met. The verification process integrates a conflict detection algorithm (used for cross-validating the safety distance requirements of mutual exclusion rules). (and the markers in the progress log), if they exist or If the conflict flag is true, it will be marked as restricted entry, obstructed exit, or mutually exclusive conflict, respectively. The output is an extended check result set, with each item containing operational deviations. Exit deviation The input is annotated as a mismatch type corresponding to the state (satisfies or mismatch).

[0075] Step S4.6 Write back the constraint segment set with mismatch annotation.

[0076] According to the extended check result set of step S4.4 and step S4.5, the main closed segment that does not meet the release criterion and the empty criterion is annotated with mismatch and the constraint segment set is written back. Specifically, the release failure is annotated as reachable mismatch, the entry restriction is annotated as accessible mismatch, the job mutual exclusion conflict is annotated as job mismatch, and the exit obstruction is annotated as exit mismatch; the start and end time of the main closed segment The restriction statement (string description, such as "reachable mismatch: entry deviation exceeds threshold") is added to the corresponding segment of the constraint segment set with the mismatch type as the key. The write-back process uses the key-value update algorithm (for exact matching and injection of new fields) to ensure that the start and end time of the constraint segment set After aligning with the main closed segment, the mismatch field is extended, and the subsequent step S5 recalculation will refer to these restriction statements to avoid repeated triggering. Finally, the updated constraint segment set is persisted to the database as the input to trigger local rearrangement.

[0077] Step S4 loads the entry and exit trajectory data by calling the access record, loads the material movement log by calling the lifting trajectory, loads the job execution record by calling the progress log, checks the entry time and release criterion segment by segment, checks the job start point and exit completion time segment by segment, and writes back the constraint segment set with mismatch annotation. The initial allocation table is verified on site. For the mispositioning problem of entry restriction and exit obstruction, the parallel comparison of access and lifting trajectory and the conflict detection of progress log are used to ensure that the mismatch annotation injects the restriction statement with the closed segment start and end time as the key, thereby leading to local adjustment in subsequent rolling recalculation, avoiding continuous deviation of the empty criterion, improving the orderliness of resource withdrawal and the timeliness of channel emptying, and providing auditable trajectory support for the same semantic continuity of queue state.

[0078] Step S4 has used the access record, lifting trajectory, and progress log to verify the initial allocation table on site, and written back the constraint segment set with mismatch annotation to ensure that the restriction statement directly references the on-site trajectory, thereby providing deviation basis for rolling recalculation and avoiding repeated conflicts. However, existing resource scheduling often leads to local mispositioning of unexecuted segments, resulting in stable main closed segments but broken subsequent input links, which in turn amplifies the risk of on-site waiting and channel congestion. To address this challenge, step S5 triggers rolling recalculation based on mismatch annotation, rearranges and replaces the unexecuted segments while preserving the main closed segments, outputs a stable allocation table, and solidifies the reference relationship between the release criterion and the empty criterion, thereby maintaining the continuous continuity of the execution rhythm and improving the predictability of resource exit.

[0079] Step S5.1 reads the mismatch annotation in the constraint segment set.

[0080] Read mismatch annotations from the updated constraint segment set after step S4, form a mismatch segment list. Specifically, iterate through each segment of the constraint segment set, filter items containing mismatch fields, including reachable mismatch, enterable mismatch, doable mismatch and retractable mismatch types, each item records start and end time , mismatch type and restriction description (string description, such as "reachable mismatch: entry deviation exceeds threshold"). The reading process uses an index scanning mode, sorts the mismatch segment list by window mapping reference, ensures alignment with the window sequence number of the initial allocation table, loads the memory cache first and then verifies the annotation integrity (checks the key value alignment of the ). The output is the mismatch segment list, which is the input source for triggering rolling recalculation.

[0081] Step S5.2 identifies unexecuted segments and isolates the main closure segment.

[0082] According to the mismatch segment list of step S5.1 and the initial allocation table, identify unexecuted segments and isolate the main closure segment. Specifically, for each entry of the initial allocation table, cross-compare the start and end time of the mismatch segment with the of the main closure segment, if they overlap, mark it as an unexecuted segment (contains a tail segment replacement request or a closed exclusion item); if the main closure segment has no mismatch, it is isolated and retained, and its four-state reference remains unchanged. The identification process uses an interval overlap detection algorithm (used to calculate the intersection area of the segment and the main closure segment, if greater than zero, it is confirmed as unexecuted), removes the closed items, forms an unexecuted segment subset, each item contains window sequence number, mismatch type, material just-in-time dependency and material identification . The output is the unexecuted segment subset and the isolated main closure segment set, which is the input basis for local rearrangement.

[0083] Step S5.3 generates a replacement candidate segment sequence.

[0084] According to the unexecuted segment subset of step S5.2, generate a replacement candidate segment sequence from the constraint segment set and the just-in-time event stream. Specifically, for each unexecuted segment, query the standby segment in the constraint segment set that matches the job face identification and task type , filter items falling after the main closure segment by start and end time , and inject the of the just-in-time event stream as the latest dependency trigger time . The generation process uses a sequence expansion algorithm (used to expand candidate chains consistent with the main closure segment sequence from the standby pool), prioritizes candidate segments (based on the order of channel identification .Incrementally), select the one with the highest coverage (the largest intersection) if multiple candidates overlap. The output is the sequence of replacement candidates, each containing the start and end time (replacement start time and end time), channel identifier , order , conflicting task pair , safety gap requirement and update dependency as the input of rearrangement verification.

[0085] Step S5.4 performs local rearrangement and four-state synchronization verification.

[0086] Local rearrangement is performed on the sequence of replacement candidates in step S5.3, and the reachable, admissible, executable and retractable four-state synchronization is verified. Specifically, the candidate sequence is inserted into the corresponding position of the subset of non-executed segments to form a temporary rearrangement chain; for each rearrangement node, the four-state judgment logic in step S3 is reused: the reachable state is checked based on the channel release record, the admissible state is checked based on the job surface admission condition, the executable state is checked based on the mutual exclusion rule, and the retractable state is checked based on the emptying criterion. If all nodes in the chain are true and the order is consistent (order is continuous), the verification is passed. The rearrangement process uses a priority queue algorithm (used to sort candidates according to the consistency degree with the main closed segment order, and the head of the queue is the optimal replacement), and if multiple candidates meet the requirements, the segment with the smallest deviation from the start of the event stream is selected . The degree of fit (the absolute difference, indicating the offset between the start of the replacement and the start of the event) is calculated. The output is the rearranged segment chain that passes the verification, which is an extended four-state Boolean sequence, serving as the basis for replacement confirmation.

[0087] Step S5.5 replaces the non-executed segments to generate a stable allocation table.

[0088] According to the rearranged segment chain that passes the verification in step S5.4, the subset of non-executed segments in step S5.2 is replaced and a stable allocation table is generated. Specifically, for each non-executed segment, the optimal item of the rearranged segment chain is used to cover its start and end time , and the entry of the isolated main closed segment is retained; the replaced chain is spliced with the main closed segment to form a complete time period sequence, which is mapped to the team ID and equipment ID. The generation process traverses the spliced sequence to construct a relational table structure, and the stable allocation table columns include window number, team ID, equipment ID, replacement time period , release criterion reference (based on the reachable state) and emptying criterion reference (based on the retractable state), ensuring semantic consistency with the initial allocation table. Finally, the stable allocation table is persisted to the database as the final output of the execution plan.

[0089] Step S5.6 solidifies the reference relationship to form a traceable archive.

[0090] The stable allocation table for step S5.5 is associated with the reference relationship of the solidification release criterion and the emptying criterion. Specifically, for each table entry, the mismatch type and the limit description of the four-state reference are extracted to generate a reference key-value pair (the key is the constraint segment number, and the value is the criterion description such as “release criterion: channel order ”); the key-value pair is associated with the replacement period , forming a traceability chain. The solidification process uses a relationship mapping algorithm (for bidirectional linking of criterion references and segment numbers) and archives to an audit log, with each item containing a window number, a reference key-value pair, and a constraint segment number, facilitating subsequent review. The output is a solidification archive set, embedded in the stable allocation table, as the final state of the traceable execution basis.

[0091] Step S5 realizes the local optimization of rolling recalculation by reading the mismatch annotations in the constraint segment set, identifying unexecuted segments and isolating the main closure segment, generating replacement candidate segment sequences, performing local rearrangement and four-state synchronization verification, replacing unexecuted segments to generate a stable allocation table, and solidifying the reference relationship to form a traceable archive. This process directly alleviates the problems of shared device migration delay and material placement lag invading channel capacity, as the rearrangement is preferentially attached to the start point of the placement event stream to reduce on-site waiting time, and the solidified reference ensures that the semantics of the release criterion and the emptying criterion do not drift, thereby strengthening the continuous link of resource deployment and the predictability of progress execution, and providing robust audit support for the same semantic continuity of the on-site queue state.

[0092] The above formulas are dimensionless numerical calculations, and the formulas are obtained by software simulation of a large amount of data to obtain a formula of the most recent real situation. The preset parameters in the formula are set by a person skilled in the art according to the actual situation.

[0093] It should be noted that the system of the present application can be deployed on the device itself to realize embedded application, or can be run on PC or other terminal with user interface, thereby meeting various hardware environments and use requirements.

[0094] The above only describes certain exemplary embodiments of the present application by way of illustration, and it is needless to say that those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present application. Therefore, the above figures and descriptions are illustrative in nature and should not be understood as limiting the scope of protection of the claims of the present application.

[0095] It has to be noted that, in the present document, the terms "first", "second", etc. merely serve the purpose of differentiation and do not require or imply any kind of ordering or sequence of the entities or actions associated therewith. Furthermore, the terms "comprising", "containing", etc. are to be interpreted as non- exclusive in the sense that a process, method, article, or apparatus that comprises a list of elements is not necessarily limited to those elements, but can include other elements not expressly listed or inherent to such process, method, article, or apparatus. An element proceeded by "comprises... a", "contains... a", etc. does not, without further restriction, exclude the presence of additional identical elements in the process, method, article, or apparatus.

[0096] The above description is only specific embodiments of the present application, but the protection scope of the present application is not limited thereto, and any person skilled in the art can easily think of changes or replacements within the technical scope disclosed by the present application, which should be covered by the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

Claims

1. A method for construction resource constrained allocation optimization based on big data, characterized in that, Comprising: S1: Read job window and subscribe material on-site event in unified time scale, generate job window table and on-site event stream as time anchor point for execution judgment; S2: Extract executable constraint segment from job window table and on-site event stream, convert lane release record and mutual exclusion rule into job face access condition to obtain constraint segment set; S3: Construct resource feasible domain with constraint segment set, perform four-state closed decision at access decision, filter team and equipment candidate period according to synchronous consistency of reachable, accessible, executable and retreatable, output initial allocation table; S4: Use access record, lifting track and progress log to perform landing check on initial allocation table, mark and write back constraint segment set for segments that do not meet release criterion and empty criterion; S5: Trigger rolling recalculation according to mismatch marking, perform local rearrangement and replacement for unexecuted segments on the premise of retaining main closed segment, output stable allocation table and solidify reference relationship of release criterion and empty criterion.

2. The big data-based construction resource constraint allocation optimization method according to claim 1, characterized in that: Step S1 reads job window data from the progress platform to generate a job window table, subscribes to on-site events from the material platform to generate an on-site event stream, and aligns the job window table and the on-site event stream with a unified time scale for anchor point verification to form a time anchor point for execution judgment.

3. The big data-based construction resource constraint allocation optimization method according to claim 2, characterized in that: Step S2 parses lane available period sequence and entry-exit order from the lane release record, parses conflict task pair and safety distance requirement from the mutual exclusion rule, and extracts preliminary constraint segment list by cutting the lane available period sequence and the mutual exclusion rule according to the start time and end time of the job window table.

4. The big data-based construction resource constraint allocation optimization method according to claim 3, characterized in that: Step S2 binds material on-site dependency from the on-site event stream to the preliminary constraint segment list to generate a bound constraint segment list. Each bound constraint segment is extended to include dependency trigger time and material identification, and the bound constraint segment list is mapped one-to-one with the job window table to generate a constraint segment set.

5. The big data-based construction resource constraint allocation optimization method according to claim 4, characterized in that: Step S3 groups resource feasible domains from the constraint segment set according to the window number of the job window table to form a time domain grid for each job window. In the resource feasible domain, reachable state is judged based on the lane release record, accessible state is judged based on the job face access condition, executable state is judged based on the job window table and the mutual exclusion rule, and retreatable state is judged based on the empty criterion and the retreat rule. Four-state Boolean sequence is generated. Continuous time periods that satisfy the four-state true are searched from the four-state Boolean sequence to form a closed segment set. Bridge connection verification is performed on adjacent closed segments in the closed segment set. Bridge connection closed segment set is formed by merging closed segments that meet the consistent start and end order and continuous entry and exit conditions.

6. The big data-based construction resource constraint allocation optimization method according to claim 5, characterized in that: Step S3 selects the start time of the start point of the bridging closure section set and the end point of the emptying requirement of the bridging closure section as the starting time of the start point of the operation window table and the main closure section, generates a closure state result, including full closure, half closure and loss closure types, for the main closure section of the full closure, the main closure section start time, the main closure section end time, the operation surface identifier, the task type and the four-state reference are mapped to the team candidate and the equipment candidate to form the distribution entry, for the half closure, the distribution entry of the main closure section is retained and the replacement request is generated for the tail section, for the loss closure, the window entry is removed and the bridging closure section set is written to the constraint segment set, and the initial distribution table is written.

7. The big data-based building construction resource constraint distribution optimization method according to claim 6, wherein: Step S4 loads the access and exit track data from the access control record to form an access control track data set, loads the material movement log from the hoisting track to form a hoisting track data set, and loads the operation execution record from the progress log to form a progress log data set, checks the access time and release criterion from the access control track data set and the hoisting track data set for each main closure section in the initial distribution table, calculates the access deviation and release state, checks the operation start time and exit completion time from the progress log data set and the access control track data set, calculates the operation deviation and exit deviation, and forms an extended check result set, each main closure section containing a deviation value and a check state.

8. The big data-based building construction resource constraint distribution optimization method according to claim 7, wherein: Step S4 labels the main closure section that does not meet the release criterion as reachable mismatch, the main closure section that does not meet the access condition as accessible mismatch, the main closure section that is mutually exclusive conflict as operable mismatch, and the main closure section that does not meet the emptying criterion as exitable mismatch according to the extended check result set, adds a restriction description to the corresponding segment of the constraint segment set with the main closure section start and end time and the mismatch type as the key, updates the constraint segment set extended mismatch field and persists to the database.

9. The big data-based building construction resource constraint distribution optimization method according to claim 8, wherein: Step S5 reads the mismatch label from the constraint segment set to form a mismatch segment list, identifies the unexecuted segment subset and isolates the main closure section set according to the mismatch segment list and the initial distribution table, generates a replacement candidate segment sequence from the constraint segment set and the just-in-time event stream, performs local rearrangement on the replacement candidate segment sequence to form a temporary rearrangement chain, verifies that the reachable state, the accessible state, the operable state and the exitable state of all nodes in the temporary rearrangement chain are true and the order is continuous, and outputs the rearranged segment chain that passes the verification.

10. The big data-based building construction resource constraint distribution optimization method according to claim 9, wherein: Step S5 replaces the unexecuted segment subset with the optimal item of the rearranged segment chain and concatenates it with the isolated main closure section set to generate a stable distribution table, extracts the four-state reference and the restriction description from the stable distribution table entry to generate a reference key-value pair, associates the reference key-value pair with the replacement period to form a traceable chain and archive it to an audit log, and each audit log contains a window serial number, a reference key-value pair and a constraint segment number, which serves as a traceable execution basis.

Images