A method and system for cascading reconfiguration of a business travel multi-leg journey in case of a disruption

Abstract

The application discloses a kind of business travel multi-section voyage sudden interruption cascade reconstruction method and system, belong to computer data processing and dispatching management technical field, it includes obtaining itinerary order data and operation event data and carries out analysis and modeling, generates cascade dependent graph;Identify sudden interruption event and carry out mapping, generate interruption positioning information, calculate influence propagation range and carry out interception, generate influence boundary subgraph;Available transport capacity data and rule constraint data are obtained and candidate construction is carried out, generate candidate link set and execute verification, generate executable combination set, calculate reconstruction score, generate reconstruction scheme set, select target reconstruction scheme and disassemble, monitor execution feedback, generate reconstruction result data.The application adopts graph modeling, influence propagation analysis and multi-objective optimization decision technology, can realize the accurate definition of interruption influence, automatic generation and optimization reconstruction scheme, finally through closed loop execution completes the quick, reliable recovery of journey.

Description

Technical Field

[0001] This invention relates to the field of computer data processing and scheduling management technology, and in particular to a cascading reconfiguration method and system for sudden interruptions in multi-segment commercial travel. Background Technology

[0002] Multi-segment business travel refers to itineraries booked by business travelers for a specific travel purpose, consisting of two or more consecutive independent flight segments. These itineraries are highly complex in terms of booking, management, and service, primarily due to the close connections and ticketing logic dependencies between the various segments. In transportation management, particularly in the areas of air transport booking and scheduling, efficiently managing these complex itineraries and providing effective solutions to unforeseen disruptions such as flight delays and cancellations are crucial for improving service quality and operational efficiency.

[0003] In related technologies, Chinese invention patent CN117649034B discloses a multi-stage road network passenger travel simulation method and system under an operational disruption event. The method includes: running a normal operation phase road network passenger travel simulation; during the operational disruption phase, reconstructing the disrupted road network topology based on disruption event information, recalculating travel paths based on the disrupted road network topology, and making decisions to adjust the travel routes for passengers entering and not entering stations based on their spatiotemporal locations and the accessibility of subsequent travel segments; and during the operational recovery phase, reconstructing the recovered road network topology based on the recovered operation information, recalculating travel paths based on the recovered road network topology, and making decisions to adjust the travel routes for passengers affected during the operational disruption phase based on their spatiotemporal locations and the accessibility of subsequent travel segments. This multi-stage road network passenger travel simulation system under an operational disruption event is applied to the multi-stage road network passenger travel simulation method under an operational disruption event.

[0004] However, the above-mentioned technical solutions focus only on "simulation" rather than "solution" and lack the goal-oriented ability to generate and optimize specific recovery solutions; their modeling granularity is coarse, only considering physical paths and ignoring complex logical constraints that determine the validity of the trip, such as ticketing rules and travel policies; it does not design a closed-loop execution and exception handling mechanism from decision-making to actual booking and rescheduling, resulting in a lack of operability and robustness of the solutions. Summary of the Invention

[0005] To address the aforementioned issues, this invention provides a cascading reconfiguration method and system for sudden interruptions in multi-segment business travel. Employing graph modeling, impact propagation analysis, and multi-objective optimization decision-making techniques, it enables precise definition of the impact of interruptions, automated generation and selection of optimal reconfiguration schemes, and ultimately, rapid and reliable recovery of the itinerary through closed-loop execution.

[0006] The above objectives can be achieved through the following approach:

[0007] A method and system for cascading reconfiguration of sudden interruptions in multi-segment business travel trips includes: acquiring itinerary order data and operational event data and performing structured parsing to generate itinerary structure data; extracting segment relationships and connection constraints from the itinerary structure data and performing graph modeling to generate a cascading dependency graph; identifying sudden interruption events in the operational event data and mapping them to interruption nodes in the cascading dependency graph to generate interruption location information; calculating the impact propagation range of the interruption location information in the cascading dependency graph and extracting the affected subgraph to generate an impact boundary subgraph; acquiring available capacity data and rule constraint data corresponding to the impact boundary subgraph and constructing candidates to generate a candidate link set; performing feasibility propagation verification based on the candidate link set and the impact boundary subgraph to generate an executable combination set; calculating and sorting the reconfiguration score of the executable combination set to generate a reconfiguration scheme set; selecting a target reconfiguration scheme from the reconfiguration scheme set and decomposing it into execution actions to generate an execution sequence; sending the execution sequence and monitoring execution feedback to update the execution status to generate reconfiguration result data.

[0008] Optionally, generating itinerary structure data includes: obtaining passenger information, order consistency information, and ticket information from the itinerary order data to generate order constraint data; obtaining a flight segment list, arrival and departure airport information, and scheduled time information from the itinerary order data to generate flight segment basic data; and merging the order constraint data and the flight segment basic data and performing consistency verification to generate itinerary structure data.

[0009] Optionally, generating the cascading dependency graph includes: extracting adjacent segments from the itinerary structure data and calculating the transfer time window to generate a connection time window constraint; extracting ticket consistency restrictions and cabin class adaptation restrictions from the itinerary structure data to generate ticket and cabin class constraints; writing the connection time window constraints and the ticket and cabin class constraints into the segment nodes and connection edges and establishing dependencies to generate a cascading dependency graph.

[0010] Optionally, generating interruption location information includes: acquiring flight status change information from operational event data and performing event normalization to generate an interruption event candidate set; matching the interruption event candidate set with the segment nodes of the cascaded dependency graph to generate an event node mapping; determining the interruption type and interruption node and interruption time based on the event node mapping to generate interruption location information.

[0011] Optionally, generating the influence boundary subgraph includes: extracting the preceding arrival state of the interrupted node based on the interruption location information and calculating the available connection starting point to generate the propagation starting point state; propagating the propagation starting point state along the cascade dependency graph and marking the affected nodes to generate the influence marking graph; and extracting the connected affected region that meets the preset conditions according to the influence marking graph and retaining the locking marks of the unaffected nodes to generate the influence boundary subgraph.

[0012] Optionally, generating the candidate link set includes: obtaining available flight information and seat availability information from available capacity data and performing reachability filtering to generate an reachable flight set; obtaining corporate travel rules and passenger preference rules from rule constraint data and performing rule encoding to generate rule feature vectors; combining the reachable flight set with the rule feature vectors and generating execution dependency conditions for each combination to generate a candidate link set.

[0013] Optionally, generating the executable combination set includes: constructing a propagation state based on the influence boundary subgraph and the candidate link set, initializing the arrival time distribution, and generating an initial propagation state; using the initial propagation state to propagate the candidate links segment by segment, and updating the ticket consistency state and connection feasibility state, generating a propagation state sequence; eliminating candidate combinations that trigger infeasibility states according to the propagation state sequence, and retaining combinations that satisfy all constraints, generating an executable combination set.

[0014] Optionally, generating the set of reconfiguration schemes includes: acquiring operational status data and extracting fluctuation features from the candidate link set to generate interruption risk features; calculating change costs and trip deviation features based on the executable combination set to generate cost deviation features; and fusing the interruption risk features and the cost deviation features and performing multi-objective sorting to generate the set of reconfiguration schemes.

[0015] Optionally, generating the reconstruction result data includes: decomposing the target reconstruction scheme into a seat-locking action, a rescheduling action, and a ticketing action, and establishing action dependencies to generate an execution sequence; sending the execution sequence and receiving action receipts returned by an external system to generate execution receipt data; updating the execution status based on the execution receipt data, and extracting a snapshot of the status of the executed actions when an action failure is detected, generating incremental reconstruction input and triggering incremental updates to the influence boundary subgraph, and outputting reconstruction result data.

[0016] Based on the same inventive concept, this invention also provides a cascading reconstruction system for sudden interruptions in multi-segment business travel itineraries. The system includes: a data parsing module for acquiring itinerary order data and operational event data, performing structured parsing, and generating itinerary structure data; a dependency graphing module for extracting segment relationships and connection constraints from the itinerary structure data and performing graph modeling to generate a cascading dependency graph; an interruption location module for identifying sudden interruption events in the operational event data and mapping them to interruption nodes in the cascading dependency graph, generating interruption location information; and an impact definition module for calculating the impact propagation range of the interruption location information in the cascading dependency graph and extracting affected sub-nodes. The system comprises the following modules: a graph, an influence boundary subgraph, a candidate construction module (for acquiring available capacity data and rule constraint data corresponding to the influence boundary subgraph and constructing candidates to generate a candidate link set), a feasibility verification module (for performing feasibility propagation verification based on the candidate link set and the influence boundary subgraph and generating an executable combination set), a reconstruction scoring module (for calculating and sorting the executable combination set and generating a reconstruction scheme set), and an execution monitoring module (for selecting a target reconstruction scheme from the reconstruction scheme set, breaking it down into execution actions, generating an execution sequence, sending the execution sequence, monitoring execution feedback to update the execution status, and generating reconstruction result data).

[0017] Compared with the prior art, the present invention has the following advantages:

[0018] 1. This invention models multiple flight segments by constructing a cascading dependency graph, achieving accurate and comprehensive assessment of the impact of sudden interruption events. This method can automatically deduce the chain reaction triggered by a single point of interruption, identify all affected flight segments, and thus... This avoids the problems of omissions or insufficient estimation of downstream impact that may occur in traditional manual judgment, ensuring the integrity and systematic nature of the reconstruction plan.

[0019] 2. This invention proposes an automated multi-constraint candidate construction and feasibility verification mechanism, improving the efficiency and quality of reconfiguration scheme generation. This method can filter and combine a large number of potentially feasible alternative paths from massive real-time capacity data based on multiple constraints such as travel policies, ticketing rules, and passenger preferences, and verify their end-to-end effectiveness through simulated propagation. This overcomes the limitations of manual search methods, such as narrow scope and low efficiency.

[0020] 3. This invention designs a closed-loop automated execution and monitoring process to ensure that the reconstruction scheme can be implemented quickly and reliably. By decomposing complex rescheduling operations into atomic execution sequences and through real-time interaction and status monitoring with external systems, this method can automatically complete a series of operations such as seat locking, rescheduling, and ticket issuance. It also possesses the ability to instantly detect execution failures and perform incremental repairs, reducing the latency and error rate of manual operations.

[0021] Other features and advantages of the invention will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention may be realized and obtained by means of the structures pointed out in the description, claims and drawings. Attached Figure Description

[0022] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 This is a flowchart illustrating a method for cascading reconfiguration of a multi-segment commercial flight that is suddenly interrupted, according to an embodiment of the present invention.

[0024] Figure 2 This is a schematic diagram comparing the continuity of connection time in an embodiment of the present invention.

[0025] Figure 3 This is a comparison chart of multi-dimensional scoring and weighted total score in an embodiment of the present invention.

[0026] Figure 4 This is a schematic diagram of a cascaded reconfiguration system for sudden interruptions of multi-segment business travel according to an embodiment of the present invention. Detailed Implementation

[0027] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0028] Reference Figure 1One embodiment of the present invention proposes a cascaded reconstruction method for sudden interruptions in multi-segment business travel. It employs graph modeling, impact propagation analysis, and multi-objective optimization decision-making techniques to accurately define the impact of the interruption, automatically generate and optimize reconstruction schemes, and finally achieve rapid and reliable recovery of the trip through closed-loop execution.

[0029] The method described in this embodiment specifically includes:

[0030] Acquire trip order data and runtime event data, perform structured parsing, and generate trip structure data;

[0031] Optionally, the generated itinerary structure data includes:

[0032] Obtain passenger information, order consistency information, and ticket information from the trip order data, and generate order constraint data;

[0033] Retrieve the flight segment list, arrival and departure airport information, and scheduled time information from the itinerary order data to generate basic flight segment data;

[0034] The order constraint data and the flight segment basic data are merged and a consistency check is performed to generate itinerary structure data.

[0035] Specifically, the system first receives itinerary order data, typically a data stream in IATA standard message format or JSON format containing passenger reservation records (PNRs). For passenger information fields, it extracts passenger name, ID number, frequent flyer membership level, and other identification identifiers. For order consistency information, it locks the globally unique passenger reservation record PNR code and associated order number; this code is a key index ensuring all flight segments belong to the same itinerary. For ticket information, it parses the e-ticket number, basic fare code, and cabin class code; this information directly determines the rules and costs of subsequent rebooking and upgrades. After processing, it outputs a structured order constraint data object, which uses the PNR code as the primary key and encapsulates all the extracted constraint information. After obtaining the itinerary order data, it locates the flight segment list section, which is usually an array or list structure. It iterates through this list, performing parsing operations on each flight segment element. For arrival and departure airport information, the three-letter IATA (International Air Transport Association) airport code is extracted. For scheduled departure and arrival times, they are uniformly converted to Coordinated Universal Time (UTC) timestamp format to eliminate errors caused by time zone differences. After parsing, an independent segment data object is generated for each physical flight segment, containing the segment number, flight number, departure airport IATA code, arrival airport IATA code, scheduled departure UTC time, and scheduled arrival UTC time. All segment objects are organized into an ordered list, forming the basic segment data. Then, using order constraint data and the basic segment data as input, fusion and verification logic is executed. The fusion operation appends global information such as PNR and ticket information from the order constraint data to each segment data object, forming a complete itinerary view. The subsequent core action is consistency verification, which aims to eliminate itineraries with logical errors or missing data. The consistency verification result of this executed verification logic is then presented. ,have:

[0036] ;

[0037] in, Total number of flight segments; The destination airport IATA code for the i-th segment of the flight; The IATA code for the departure airport of the (i+1)th segment of the journey; Let i be the planned arrival time in UTC for the i-th segment of the journey; The planned departure UTC time for the (i+1)th segment of the flight; To minimize connection time, engineering parameters are dynamically retrieved from preset rules or configuration libraries based on the airports, terminals, and flight types involved in the current itinerary. For example, for domestic transfers within the same terminal... The timeframe is typically between 60 and 90 minutes. The validation result C is true only when the geographical and temporal logic of all adjacent flight segments satisfies the constraints. After successful validation, the final itinerary structure data is output. This data structure is a complete object containing global order constraints and a validated, ordered list of flight segment information, serving as input for the next stage of generating the cascading dependency graph. Figure 2 As shown, in subgraph (a), the actual transfer time of 150 minutes is greater than the minimum connection time (MCT) of 90 minutes, so the verification passes; in subgraph (b), in scenario B, the transfer time of 60 minutes is less than the MCT, and the passenger cannot complete the connection, so the verification fails.

[0038] For example, if there is a travel order data, and passenger Z has booked a connecting flight from airport a to airport c, with a layover at airport b, we first obtain and parse the order data for this travel itinerary. The data is in JSON format and includes the passenger reservation record PNR code NG8XYZ. First, we parse the passenger information field to extract the passenger name Z; then we parse the order consistency information to lock the globally unique PNR code NG8XYZ and the associated order number; finally, we parse the ticket information to obtain the electronic ticket number XXX-1234567890. This information is then integrated to generate order constraint data. Simultaneously, the flight segment list is parsed to obtain information for the first flight segment: departure airport is airport a, arrival airport is airport b, planned departure time is 09:00 UTC on October 26th, XX year, and planned arrival time is 12:00 UTC on the same day; information for the second flight segment: departure airport is airport b, arrival airport is airport c, planned departure time is 14:30 UTC on the same day, and planned arrival time is 07:30 UTC the following day. This information generates the basic flight segment data. Subsequently, fusion and consistency checks are performed, appending order constraint data to the two flight segments. We verify the validity of the connection using the formula for the consistency check result. In this example, the total number of flight segments n equals 2, and the check only needs to be performed when i equals 1. The arrival airport of the first flight segment is the same as the departure airport of the second flight segment, therefore... The conditions are met. The planned arrival time for the first flight segment is 12:00 UTC, and the planned departure time for the second flight segment is 14:30 UTC. According to the rules for international-to-international transfers at airport b, we obtain a minimum connection time of 90 minutes from the configuration database. Calculating the time difference, 14:30 minus 12:00 equals 2 hours and 30 minutes, or 150 minutes. Since 150 minutes is greater than or equal to 90 minutes, the time constraint is also met. Because all conditions are true, the final consistency check result is true. Output a complete itinerary structure data, which includes passenger Z's personal information, ticket number, and verified, ordered details of the two flight segments. By automatically transforming raw, unstructured order data into a logically validated, complete, and readily available standardized itinerary object, a data foundation is provided for the entire flight processing workflow.

[0039] Extract the segment relationships and connection constraints from the itinerary structure data and perform graph modeling to generate a cascaded dependency graph;

[0040] Optionally, generating the cascading dependency graph includes:

[0041] Extract adjacent flight segments from the itinerary structure data and calculate the transfer time window to generate connection time window constraints;

[0042] Extract ticket consistency restrictions and cabin class adaptation restrictions from the itinerary structure data to generate ticket and cabin class constraints;

[0043] Write the connection time window constraint and the ticket cabin class constraint into the flight segment node and connection edge and establish dependency relationship to generate a cascaded dependency graph.

[0044] Specifically, the process first receives the itinerary structure data generated in the previous stage and iterates through the segment list to identify all adjacent segment pairs. For each pair of adjacent segments i and i+1, the actual transfer time is calculated by subtracting the planned arrival time of the preceding segment from the planned departure time of the subsequent segment. Then, based on the connecting airport code, terminal information, and international / domestic attribute of this segment pair, the corresponding minimum connection time is queried from a pre-configured database of minimum airport connection times. Simultaneously, a maximum transfer time parameter configured by the business is applied. This parameter is used to exclude long-term stays planned by passengers and is typically set between 8 and 24 hours. Finally, a connection time window constraint is generated for each connection, and its effectiveness can be analyzed through connection effectiveness analysis. The calculation of this connection effectiveness... ,have:

[0045] ;

[0046] Where V represents the validity of the connection, and a Boolean value of true indicates that the constraint is satisfied; This is the actual transfer time; This is the maximum allowed transfer time configured in the business plan. The analysis continues with the ticket information in the itinerary structure data. Regarding ticket consistency restrictions, it checks whether all flight segments in the itinerary are associated with the same or consecutive e-ticket numbers. This is a prerequisite for ensuring the itinerary is protected by the airline's connecting flight agreement; single-ticket connecting flights are the highest level of protection. Regarding cabin class adaptation restrictions, it parses the basic fare code, which contains complex rules about rescheduling, transfers, and upgrades. These rules are decoded into executable constraints through the internal ticketing engine or by calling the external GDS global distribution system interface. For example, a specific economy class discount ticket may only allow rescheduling to the same or higher sub-class, but not transfers to other airlines. These extracted rules are structured into ticket cabin class constraint objects. The graph is then constructed in this step. First, each flight segment in the itinerary structure data is instantiated as a segment node, with node attributes containing basic information such as flight number, departure and arrival airports, and times. Secondly, for each pair of adjacent flight segments, a directed connecting edge is established between the corresponding two segment nodes, with the direction from the preceding segment to the following segment, representing the flow direction and dependency relationship of the itinerary. The key integration step is to write the constraints generated in the first two steps into the corresponding elements of the graph. The connecting time window constraint is attached as an attribute to the connecting edge, as it describes the relationship between two nodes; while ticket class constraints, such as the list of classes that allow rebooking or a Boolean flag indicating whether transfer is allowed, are attached as attributes to each flight segment node. Through this step, a complete cascading dependency graph is generated. This graph is a directed acyclic graph, and its nodes and edges carry rich constraint information, characterizing the cascading dependencies within multiple flight segments.

[0047] For example, based on the itinerary structure data generated in the previous step, we first identify adjacent flight segment pairs and their transfer times, which are calculated by subtracting the planned arrival time of the preceding flight (12:00 UTC) from the planned departure time of the subsequent flight (14:30 UTC), yielding an actual transfer time of 150 minutes. We then query the pre-configured database and find that the minimum connection time for airport B is 90 minutes, applying the maximum transfer time configured in the business, which is set to 10 hours (600 minutes) here. Subsequently, we analyze the connection effectiveness using a formula. Both conditions are met, so V is true, indicating that the connection is valid in time; this is the connection time window constraint. Next, the ticket class constraint is extracted. Since the entire trip uses a single electronic ticket number XXX-1234567890, it is identified as a single-ticket connecting trip, and the ticket consistency constraint is satisfied. By parsing the basic fare code, it is confirmed that the ticket allows free rebooking to economy class on the same alliance airline in the event of an abnormal event. Finally, graph modeling begins, instantiating the first segment number as the first node of the graph and the second segment number as the second node. A connecting edge is established between these two nodes, pointing from the first node to the second node. The calculated connection time window constraint of 150 minutes and V being true is written as an attribute to this connecting edge; at the same time, the ticket class constraint, i.e., single-ticket connecting trip and allowing rebooking to economy class on the same alliance, is written as an attribute to the two segment nodes. Thus, a cascading dependency graph depicting the internal dependencies of the passenger's Z-trip is generated.

[0048] Identify sudden interruption events in the runtime event data and map them to interruption nodes in the cascaded dependency graph to generate interruption location information;

[0049] Optionally, the generation of interruption location information includes:

[0050] Obtain flight status change information from runtime event data and normalize the events to generate a candidate set of interruption events;

[0051] The candidate set of interruption events is matched with the segment nodes of the cascaded dependency graph to generate an event node mapping;

[0052] Based on the event node mapping, the interrupt type is determined, the interrupt node and the interrupt time are identified, and interrupt location information is generated.

[0053] Specifically, the system continuously receives operational event data streams from airline operations control centers, global distribution systems, or third-party flight data service providers. This data is typically in JSON format. First, this heterogeneous data is parsed to extract flight identifiers, usually consisting of a two- or three-digit airline code and flight number, as well as event types such as delays, cancellations, and diversions, and related time data. The core of the event normalization operation is to uniformly convert different event descriptions, such as "FLTCXA888CNLD" and "StatusCodeUC," into an internally defined "CANCEL" event enumeration. For delay events, a key engineering parameter, the interruption trigger threshold, is set. For example, only when the delay exceeds 30 minutes is the event considered a potential interruption and added to the interruption event candidate set. This candidate set is a structured data list, where each item contains the flight identifier, the normalized event type, the event occurrence time, and the updated estimated time information. Each event in the interruption event candidate set is traversed, using the flight identifier from the event as the query key. This flight identifier is composed of the flight number and the planned execution date to ensure unique matching. The cascading dependency graph is searched for nodes with the same flight number and a planned departure date that matches the event date. Upon successful matching, an event node mapping is generated, which is a tuple containing the unique ID of the event and the unique ID of the corresponding flight segment node. If an event cannot find a matching node in the graph, it is marked as an irrelevant event and archived, not proceeding to the next step. After obtaining the event node mapping, an interruption determination is performed on each mapping. For deterministic interruption events such as "cancellation" or "diversion," the corresponding flight segment node is directly marked as an interruption node. For conditional interruption events such as "delay," a forward check is performed to determine whether it constitutes a substantial interruption. This determination logic calculates the boolean value for whether the delay event of the i-th flight segment node constitutes an interruption. ,have:

[0054] ;

[0055] in, The latest estimated arrival time for delayed segment i is derived from the interruption event itself; The original scheduled departure time for the subsequent flight segment i+1 is obtained from the node attributes of the cascading dependency graph. When this inequality holds, it means that the passenger's transfer time has been compressed to at least the legal minimum, constituting a de facto connection interruption. If true, the system outputs a structured interrupt location information. This information explicitly includes the interrupt node's ID, the interrupt type (e.g., "cancellation" or "delay leading to interruption"), and the original event time that triggered the interrupt, providing a precise starting point for calculating the subsequent impact range.

[0056] For example, on the day of passenger Z's departure, an operational event data message is received from the airline stating that flight MU5XX has been canceled. First, this event is normalized, converting the external state described as "CNLD" to the internally defined "CANCEL" interruption event, and adding it to the interruption event candidate set. Then, using the flight identifier MU5XX and the scheduled execution date of October 26th, XX year, it is matched against the cascading dependency graph generated in the previous stage, successfully locating the first segment node representing the flight and generating an event node mapping. Next, the interruption type is determined. Since the event type is "CANCEL," a deterministic interruption event, the segment node is directly marked as an interruption node, and the interruption time is recorded as the event reception time, for example, 07:00 UTC. In this example, because it is a cancellation event, no interruption determination logic formula is needed. However, in contrast, if the received event is that MU5XX is delayed by 3 hours, the latest estimated arrival time will become 15:00 UTC. In this case, the interruption determination logic formula will be used. If k equals 1, the original scheduled departure time is 14:30 UTC, and the minimum connection time is 90 minutes. The calculation result is 14:30 minus 15:00, which is -30 minutes. This value is less than 90 minutes, therefore... If true, this delay is considered a de facto disruption of the connection. Returning to our cancellation scenario, an interruption location information is ultimately generated, clearly indicating that the segment node representing MU5XX in the cascading dependency graph is the interruption node, and the interruption type is "cancellation". Through event normalization and precise mapping with the cascading dependency graph, the process can automatically complete the precise location from the original information of "a flight has been cancelled" to "the first segment of the passenger's journey has been interrupted", providing a clear and unambiguous trigger signal and starting point for initiating a targeted refactoring process.

[0057] Calculate the impact propagation range of the interruption location information in the cascaded dependency graph and extract the affected subgraph to generate an impact boundary subgraph;

[0058] Optionally, generating the influence boundary subgraph includes:

[0059] Based on the interruption location information, the preceding arrival state of the interruption node is extracted and the available connection starting point is calculated to generate the propagation starting point state.

[0060] Propagate backward along the cascaded dependency graph from the propagation starting state and mark the affected nodes to generate an influence marking graph;

[0061] Based on the influence marker graph, the connected affected regions that meet the preset conditions are extracted, and the lock markers of unaffected nodes are retained to generate an influence boundary subgraph.

[0062] Specifically, the interruption node is first identified. If the interruption node is the first segment of the journey, the propagation starting state is defined as the original departure airport of that segment and the current system time, indicating that the passenger's journey has not yet begun. If the interruption node is not the first segment, its unique direct preceding segment node is located. In this case, the propagation starting state is defined as the arrival airport of that preceding segment, and the planned arrival time or updated estimated arrival time of that preceding segment. This state represents the last definite location and time point that the passenger could reach before the interruption occurred, and is the benchmark point that all subsequent reconstruction schemes must connect to. Using the propagation starting state and the interruption node generated in the first step as input, a directed graph traversal algorithm is performed on the cascading dependency graph, usually using depth-first search or breadth-first search. The traversal starts from the interruption node and visits all its successor nodes along all outgoing edges. For each visited node, an "affected" flag is added to its attributes. For example, in a four-segment journey, if the second segment is canceled, the second segment is first marked as "directly affected," and then the process continues, marking the third and fourth segments as "cascadedly affected." After the traversal is complete, the entire cascade dependency graph is appended with influence state information, forming an influence labeling graph. A truncation operation is then performed based on the influence labeling graph. First, all nodes marked as "directly affected" or "cascadedly affected" and their connecting edges are extracted, forming a connected affected region. Simultaneously, a preset truncation condition is applied, and a Boolean value is used to calculate whether node k is included in the final influence boundary subgraph. ,have:

[0063] ;

[0064] in, It is the state of node k in the influence of the marker graph. Represents "directly affected" This means "cascading is affected"; The state of node k must be either "directly affected" or "cascadedly affected", meaning that the node must have been affected by the interruption event to be included in the influence boundary subgraph. It is the planned takeoff time of node k; It is the timestamp of the original interrupt event; A key business parameter is called the "reconstruction time window," which, for example, is set to 72 hours, to avoid reconstructing itineraries weeks later due to a short-term interruption. For unaffected flight segment nodes in the graph, especially completed segments, a "locked" marker is added. Finally, the output influence boundary subgraph is an independent graph structure containing all affected nodes and edges that meet the conditions, carrying propagation start-point state information, and explicitly defining the outer locking constraints. It fully defines the solution space of the reconstruction problem.

[0065] For example, after receiving the interruption location information about the cancellation of flight MU5XX generated in the previous stage, the scope of its impact is calculated. First, the interruption node, namely the MU5XX segment node, is identified. Since this node is the first segment of the journey, the propagation starting point state is defined as the departure airport 'a' and the current system time 07:00 UTC. Next, starting from this interruption node, propagation proceeds backward on the cascading dependency graph. It first marks the MU5XX node as "directly affected," and then, along the unique outgoing edge, visits the node of the subsequent second segment of the journey and marks it as "cascadingly affected," thus completing the generation of the impact marking graph. Subsequently, a subgraph is extracted based on the impact marking graph, and a Boolean formula is used to determine whether a node is included in the impact boundary subgraph. Here, the reconstruction time window H is set to 72 hours, and the timestamp of the interruption event is 07:00 UTC. For node MU5XX, its status is "directly affected," with a planned departure time of 09:00 UTC. (09:00 minus 07:00) is 2 hours, which is much less than 72 hours, therefore it is true. For node number 2, its status is "cascadedly affected," with a planned departure time of 14:30 UTC. (14:30 minus 07:00) is 7.5 hours, which is also less than 72 hours, therefore it is also true. There are no unaffected segments in the graph, so there is no need to add a "locked" marker. Finally, an impact boundary subgraph is extracted. This subgraph contains the marked nodes MU5XX and 2, along with the connecting edges between them, and includes the propagation starting point at airport a and the current time. Through automated propagation and marking, the part that truly needs repair can be extracted from the complex travel network, namely the entire path from airport a to airport c. This avoids misoperation of irrelevant flight segments, and at the same time, by reconstructing parameters such as the time window, the solution range is limited to a reasonable time, thus reducing the problem size.

[0066] Obtain available capacity data and rule constraint data corresponding to the influence boundary subgraph and construct candidates to generate a candidate link set;

[0067] Optionally, the generated candidate link set includes:

[0068] Obtain available flight information and seat availability information from available capacity data and perform reachability filtering to generate a set of reachable flights;

[0069] Obtain enterprise travel rules and passenger preference rules from the rule constraint data, encode the rules, and generate rule feature vectors;

[0070] The set of reachable flights is combined with the rule feature vector, and execution dependency conditions are generated for each combination to generate a set of candidate links.

[0071] Specifically, the process first receives the affected boundary subgraph and parses out the starting point of the reconstruction (the arrival airport of the preceding segment) and the target endpoint (the original arrival airport of the last segment in the affected area). Using this information, a flight search request is initiated to an external data source of available capacity, typically a Global Distribution System (GDS) or an airline direct connection API. Key parameters of this request include the departure airport, arrival airport, and a time window, which typically starts from the point of available connection after the interruption and lasts for a configurable reconstruction period, such as 48 hours. After obtaining the returned available flight and seat availability information, accessibility filtering is performed. The filtering logic excludes flights with departure times earlier than passenger availability times to ensure the possibility of physical connections. Finally, a structured set of accessible flights is output, where each item represents an actual flight with available seats. Rule constraint data stored in passenger profiles or enterprise configurations is also retrieved. This data includes corporate travel rules, such as cost center budget caps, cabin class restrictions (Y / B / M economy class), and permission to operate only with Star Alliance member airlines; and passenger preference rules, such as preference for window seats, avoiding red-eye flights (departure times between 0:00 and 6:00 AM), and loyalty programs for specific airlines. The rule encoding process quantifies these textual rules, for example, converting airline alliance preferences into a set of allowed airline codes, cabin class restrictions into a list of allowed cabin class codes, and setting price caps to floating-point numbers. After processing, a unified rule feature vector is generated, encapsulating all non-physical constraints related to the passenger and itinerary. Each flight in the reachable flight set is compared one by one with the rule feature vector. This process can be represented by a comprehensive verification function that determines whether a flight is a candidate. The verification result obtained using this process determines whether a flight is a candidate. ,have:

[0072] ;

[0073] in, The airline operating the flight; For the group of airlines permitted by the rules; This is the lowest available fare for the flight currently searched. This refers to the budget cap specified in the rules. This refers to the collection of available cabin classes for a flight. For each... For flights deemed valid, the process doesn't simply involve listing them; rather, it generates execution dependencies for them. These dependencies specify the prerequisites for a flight to become a valid link, such as "valid only if booked in Class M and the ticket price does not exceed 3500 yuan." Ultimately, the output set of candidate links is a structured list containing all flights that pass the rule validation, with each flight accompanied by a specific list of execution dependencies, providing precise input for the next step of feasibility propagation validation.

[0074] For example, based on the influence boundary subgraph generated in the previous step, we begin searching for alternative solutions. The subgraph clearly defines the starting point of the reconstruction as airport a, the ending point as airport c, and the available time starting from the current moment. Based on this, we initiate a flight search request to the GDS (Global Distribution System) to query available flights from a to c within the next 48 hours. Multiple available flight information is returned. After accessibility filtering and removing flights whose departure times have passed, a set of available flights is generated, including one direct flight scheduled to depart at 13:00 UTC, and one connecting flight combination. Next, we obtain and encode the rule constraint data for passenger Z, generating a rule feature vector containing a cost cap of 8000 RMB and a cabin class restriction to economy class. Then, we perform a combined verification of the available flights and the rule feature vector. We determine whether a flight can be considered a candidate using a formula based on the verification result. If the operating airline is a certain airline (CA), and the passenger has no airline preference, then… True; the lowest available ticket price is 7500 yuan, which is less than the budget limit of 8000 yuan, therefore... It is true; its set of available cabins includes Economy Class Y, which intersects with the set of cabins allowed by the rules, therefore... The condition that the set is not empty is true. If all conditions are met, the candidate's validation result is true. Therefore, the execution dependency condition "booked in Y class and the ticket price is no higher than 7500 yuan" is generated. For the transit combination, the ticket price is found to be 9200 yuan, exceeding the budget limit. If the result is false, the candidate's validation result is false, and the combination is eliminated. Ultimately, the output candidate link set contains only one valid link, along with its execution dependencies. By automatically connecting to external capacity data and combining it with internal rules for filtering, this step reduces the burden of manual queries and comparisons, meeting the personalized cost and service level requirements of passengers or businesses.

[0075] Based on the candidate link set and the influence boundary subgraph, a feasibility propagation verification is performed to generate an executable combination set;

[0076] Optionally, generating the executable combinatorial set includes:

[0077] Based on the influence boundary subgraph and the candidate link set, a propagation state is constructed and the arrival time distribution is initialized to generate an initial propagation state;

[0078] The candidate links are propagated segment by segment using the initial propagation state, and the ticket consistency state and connection feasibility state are updated to generate a propagation state sequence.

[0079] Based on the propagation state sequence, candidate combinations that trigger infeasible states are eliminated, and combinations that satisfy all constraints are retained to generate an executable combination set.

[0080] Specifically, firstly, based on the reconstruction starting point determined by the influence boundary subgraph, one or more initial propagation states are created. The core of each state is the arrival time distribution, which records the earliest available time for passengers at the airport at the reconstruction starting point. This time point directly originates from the propagation starting point state in the influence boundary subgraph. Simultaneously, the initial propagation state also contains the initial value of the ticket consistency state. For example, if the previously unaffected flight segment is a ticket for an international airline, the ticket consistency state will be marked as "CA-Ticketed," providing a basis for subsequent judgments on whether consecutive ticketing or rebooking is possible. A method similar to dynamic programming or state space search is employed. Starting from the initial propagation state, all links in the candidate link set that can originate from the current state (i.e., departure airport matching) are traversed. For each matched candidate link, one propagation is performed. The core of the propagation action is updating the state, as follows: First, the arrival time distribution is updated, setting the arrival airport of the new state to the arrival airport of the link, and the arrival time to the arrival time of the link. Secondly, the ticket consistency status is updated. For example, if the current status is "CA-Ticketed" and the selected link is an Airline A flight, the system will determine whether a transfer can be made according to the pre-defined inter-airline ticketing agreement rules. If not, the ticket consistency status will be marked as "Inconsistent-Break". Finally, the connection feasibility status is verified, using the verification logic to calculate a Boolean value indicating the feasibility of the current link connection. ,have:

[0081] ;

[0082] in, This is the planned takeoff time for the current candidate link; This refers to the arrival time in the previous propagation state. After each propagation, a new propagation state is generated, and this new state, along with the link that performed the propagation, is recorded as a node in the propagation state sequence. This process is recursively performed until all possible combinations reach the target destination airport defined by the influence boundary subgraph. After all propagation processes are completed, a series of propagation state sequences from the start point to the end point are obtained, each sequence representing a potential reconstruction combination. At this point, these sequences are traversed and filtered. The core of the filtering is to check whether there are any nodes in the sequence that trigger infeasible states. An infeasible state is defined as a state where, during the propagation process, the ticket consistency state is marked as "Inconsistent-Break," or any step's connection feasibility state. A false propagation node is considered a false propagation node. If a propagation state sequence contains at least one such infeasible node, the entire candidate combination represented by the sequence will be eliminated. Only combinations that meet the time requirements at every step from beginning to end and whose ticketing logic remains consistent throughout will be retained. Ultimately, the output set of executable combinations is a list, where each item is a complete reconstructed path consisting of multiple candidate links in an ordered manner, and whose feasibility has been verified end-to-end.

[0083] For example, we perform a feasibility propagation check based on the candidate link set generated in the previous step and the influence boundary subgraph defining the reconstruction start and end points. First, we construct an initial propagation state, where the starting point is airport A, the earliest available time for passengers is the current time 07:00 UTC, and the original ticket status is recorded as "781-Ticketed". Next, we propagate the candidate links using this initial state. Since this is the first segment of the journey, we perform a formal check using a formula for connection feasibility. The planned departure time of the current candidate link is 13:00 UTC, and the arrival time of the previous propagation state is the passenger's available time at airport A at 07:00 UTC. Since it is the originating point, there is no actual transfer. The result is 0. The calculation result is (13:00 minus 07:00), which is 6 hours, much greater than 0. True. During the propagation process, the ticket consistency status is updated. Since the original tickets are from China Eastern and Japan Airlines, and the candidate link is from Air China, the airline agreement determines whether a transfer is possible. Assuming it's determined here that a direct transfer is not possible and a new ticket needs to be purchased, the ticket status is updated to "Inconsistent-Break-Reissue-Required." This doesn't mean it's infeasible, but rather that specific processing is required. Because it's a direct flight, it reaches the target destination airport C after one propagation, forming a complete propagation state sequence. Subsequently, all sequences are filtered. In this example, the only sequence, although the tickets are inconsistent, has feasible connection. The condition remains true throughout, and there are no other states that would render it infeasible. Therefore, this combination is retained. Ultimately, the generated set of executable combinations includes one item: a refactoring path consisting of a single link, validated for end-to-end feasibility. State tracking of ticket consistency provides clear guidance for subsequent execution actions, ensuring the business operability of the final solution.

[0084] Calculate and sort the refactoring scores for the executable combination set to generate a set of refactoring schemes;

[0085] Optionally, the set of generated reconstruction schemes includes:

[0086] Acquire operational status data and extract fluctuation features from the candidate link set to generate interruption risk features;

[0087] Based on the executable combination set, the change cost is calculated and the trip deviation feature is calculated to generate the cost deviation feature;

[0088] By integrating the interruption risk characteristics and the cost deviation characteristics and performing multi-objective sorting, a set of reconstruction schemes is generated.

[0089] Specifically, for each candidate link in the executable combination set, real-time operational status data is actively acquired. This data mainly includes the flight's historical on-time rate, typically data from the past 30 to 90 days, and current and future weather forecasts for the departure and arrival airports, such as the presence of severe weather like thunderstorms or low visibility. A risk assessment model extracts and calculates these fluctuation characteristics, assigning a quantified interruption risk score to each candidate link. This score is typically normalized to a range of 0 to 1; a higher score indicates greater uncertainty in future operation. For example, to calculate the normalized interruption risk score for the i-th candidate link... ,have:

[0090] ;

[0091] in, The original risk value for link i is determined by the following rules: if there is severe convective weather along the route or the historical on-time rate is less than 85%, the original risk value is set to 1 minus the on-time rate; otherwise, the on-time rate value is used. , These are the minimum and maximum original risk values ​​among all current candidate links; each complete set of executable combinations is traversed and compared with the original, affected itinerary segments for calculation. The change cost is calculated as the sum of the fares for all candidate links in the new combination, plus any potential rebooking fees, and minus the refundable amount for the original interrupted segment. For calculating the change cost... ,have:

[0092] ;

[0093] in, The number of candidate links in the new combination; Let be the ticket price for the i-th link; For rescheduling fees; This represents the refundable amount for the original interrupted flight segment. The itinerary deviation feature is a multi-dimensional vector that includes at least the time deviation from the final destination (the difference between the new arrival time and the original scheduled arrival time, in minutes); the change in the number of transfers; and the service class deviation, such as whether it involves changing from a non-alliance airline to an alliance airline, or downgrading from business class to economy class. After these calculations, a cost deviation feature vector containing specific numerical values ​​is generated for each executable combination. A multi-objective ranking algorithm is used to calculate the final reconstruction score. ,have:

[0094] ;

[0095] in, This represents a comprehensive scalar value for the characteristics of travel deviation, taking time deviation as an example. , The final arrival time of the new plan, This is the originally scheduled arrival time; For the maximum and minimum normalization function, in the special case where there is only one unique executable combination, a normalization strategy based on a preset benchmark will be enabled. This strategy will call the preset cost benchmark range for a specific route or business scenario from the configuration library, such as a preset minimum fare and maximum fare, and a deviation tolerance range, such as a minimum deviation of 0 minutes and a maximum acceptable deviation of 480 minutes. , , These are the weighting coefficients for interruption risk, change costs, and trip deviation, respectively. These are key business configuration parameters, and their sum is 1. Their values ​​reflect decision-making preferences; for example, for cost-sensitive customers... The value can be set to 0.7. After calculating the refactoring score for each executable combination, all solutions are sorted in ascending order of their refactoring scores, ultimately generating and outputting an ordered set of refactoring solutions. The top-ranked solution is the primary recommended refactoring solution. For example... Figure 3 As shown, after setting a cost-priority weighting strategy, although Option B has the highest deviation, it has the lowest score in the cost dimension, which accounts for the majority of the time. Therefore, its final total score, i.e., the reconstruction score, is 0.440, which is better than Option A and Option C. Thus, it is identified as the recommended option.

[0096] For example, we score and rank the executable combination set generated in the previous stage. First, we obtain the flight operation status data and find that its on-time rate over the past 30 days is 90%, and the weather for route a to c is favorable in the future. According to the risk assessment model, the original risk value corresponding to a historical on-time rate of 90% is 0.9. Since there is only one candidate solution, we cannot normalize it; here, the interruption risk feature score can directly use a mapping value negatively correlated with the on-time rate, for example, set to 0.1. Next, we calculate the change cost and itinerary deviation features. The refundable amount for the original interrupted MU5XX and the second segment of the itinerary is 4000 yuan. The ticket price for the new solution is 7500 yuan, and the rebooking fee is 200 yuan. We calculate the change cost... (Yuan). The travel deviation feature D is calculated as the difference between the final arrival time of the new route and the original planned arrival time. If the flight is expected to arrive at c at 09:00 UTC, and the original plan was 07:30 UTC, then the time deviation D is 90 minutes. At this point, a multi-objective ranking algorithm is used to calculate the final reconstruction score S. If the interruption risk weight... Equal to 0.2, change cost weight Equal to 0.5, travel deviation weight The value equals 0.3. Since there is only one option, for ease of comparison, we unify the units of measurement for cost and deviation. Based on business configuration, a baseline range is set for the reconfiguration cost of this route, with a minimum reference cost of 3000 yuan and a maximum reference cost of 12000 yuan; a baseline range is also set for itinerary deviation, with a minimum reference deviation of 0 minutes and a maximum acceptable deviation of 480 minutes. Therefore, the normalized value of the change cost C is... The normalized value of the deviation of the journey from D is ,but This score reflects the overall performance of a single solution under preset evaluation criteria, with lower scores indicating better performance. Ultimately, an ordered set of reconstruction solutions is output. By integrating multiple factors such as risk, cost, and deviation, and allowing for weight adjustments based on business needs, the system can intelligently recommend the solution that best aligns with the overall interests of passengers or businesses from among multiple feasible options, improving the quality and efficiency of decision-making.

[0097] Select a target reconstruction scheme from the set of reconstruction schemes and break it down into execution actions, generate an execution sequence, send the execution sequence and monitor execution feedback to update the execution status, and generate reconstruction result data.

[0098] Optionally, the generated reconstruction result data includes:

[0099] The target reconstruction scheme is decomposed into locking seat action, rescheduling action and ticketing action, and action dependencies are established to generate an execution sequence;

[0100] Send the execution sequence and receive the action receipt returned by the external system, and generate execution receipt data;

[0101] The execution status is updated based on the execution receipt data, and when an action failure is detected, a state snapshot of the executed action is extracted, an incremental reconstruction input is generated, and an incremental update of the influence boundary subgraph is triggered, and the reconstruction result data is output.

[0102] Specifically, the process begins by selecting a target restructuring scheme from the ranked set of schemes. This is typically the top-ranked scheme or one that has been manually confirmed. Each new candidate link within this scheme is analyzed and converted into standard airline business actions. These actions primarily include seat locking (reserving a seat and generating a new temporary PNR record), flight rescheduling (modifying the itinerary based on the original ticket), and ticketing (paying and confirming the ticket). Dependencies between these actions are established based on business logic, forming a directed acyclic graph (DAG). For example, seat locking must be successfully executed first to obtain the PNR code before subsequent ticketing actions can be performed. Based on this dependency, a linear execution sequence is generated—an ordered list of actions containing specific instruction parameters such as flight number, cabin class, and passenger information. Following the execution sequence, the action instructions are sent one by one to external systems, such as the GDS (Global Distribution System) or airline systems, via an API interface. After each transmission, a waiting state is entered, with a timeout set, for example, 30 to 60 seconds. Upon receiving an action receipt from the external system, the receipt content is immediately parsed. These receipts are typically XML or JSON messages containing success or failure codes and related data. Structured execution receipt data is generated based on these receipts, and the internally maintained execution state machine is updated accordingly. For example, if a receipt for a seat-locking action contains a valid PNR code, the execution status of that action is updated to "success," and the PNR is stored in a state snapshot. During execution, if an action failure is detected, such as being informed that the seat is already occupied when purchasing a ticket, or a network timeout occurs, this mechanism is triggered. First, a state snapshot of successfully executed actions is extracted. This snapshot records all completed operations and acquired resources up to the failure node, such as the newly generated temporary PNR. Next, an incremental reconstruction input is generated. This input is essentially a new, smaller-scale reconstruction problem, whose boundary conditions are updated with the information in the state snapshot. For example, if the first segment in a combination has been successfully ticketed, and the second segment has failed, the goal of incremental reconstruction is to find alternatives only for the second segment and its subsequent journeys, while the ticketed first segment becomes an immutable "locked" precondition. This incremental reconstruction input triggers an incremental update to the affected boundary subgraph, locking the executed portion and redefining the subproblem to be solved. It then restarts the process from candidate construction to solution selection, but on a significantly smaller scale. Whether the entire process is successful or enters the incremental reconstruction loop after partial success, it ultimately outputs a detailed reconstruction result dataset, recording the final confirmed itinerary, logs of all executed actions, and the final execution status.

[0103] For example, the top-ranked target refactoring scheme is selected from the set of refactoring schemes generated in the previous stage. This scheme is first decomposed into execution actions, and dependencies are established. Analysis reveals that the original ticket cannot be directly rebooked; therefore, the generated execution sequence is as follows: First, execute the seat-locking action, reserving a seat in class Y for passenger Z on this flight; second, after successfully locking the seat and obtaining a new PNR, execute the ticketing action. Next, the seat-locking action instruction is sent to the GDS system via API, and execution feedback is monitored. A few seconds later, the GDS system returns an action receipt containing a success code and the new PNR code "QK2PQR". This receipt is parsed, execution receipt data is generated, and the internally maintained execution status is updated to "seat lock successful," while the PNR code QK2PQR is stored in a state snapshot. Subsequently, based on this state snapshot, the second action in the sequence, the ticketing action, is sent, with the instruction containing the PNR code QK2PQR and payment information. However, at this point, GDS returns a failure receipt with the reason "SEATGONE," meaning the seat has already been booked by someone else. Upon detecting an action failure, an incremental refactoring is immediately triggered. It extracts a snapshot of the state of successfully executed actions; this snapshot is empty because although a temporary PNR was locked, no valuable assets such as tickets were generated. The incremental refactoring input is generated, the core of which is that the problem remains unchanged—still from a to c—but the option of class Y for that flight needs to be excluded. This input triggers an incremental update to the affected boundary subgraph, effectively restarting the process from the candidate constructs, but in the new candidate link set, class Y for that flight will be marked as unavailable. This loop continues until a new solution is found and all steps are successfully executed, or all feasible solutions fail. Finally, assuming the second loop finds another flight and successfully issues a ticket, a complete refactoring result dataset is output, recording the newly confirmed flight information for passenger Z, detailed logs of the two execution attempts, and the final success status. By decomposing the solution into atomic execution actions and establishing dependencies, the refactoring operation can be advanced systematically.

[0104] Based on the same inventive concept, such as Figure 4 As shown, the present invention also provides a cascading reconfiguration system for sudden interruptions in multi-segment business travel, the system comprising:

[0105] The data parsing module is used to acquire trip order data and runtime event data, perform structured parsing, and generate trip structure data;

[0106] The dependency graphing module is used to extract the segment relationships and connection constraints in the itinerary structure data and perform graph modeling to generate a cascaded dependency graph.

[0107] An interrupt location module is used to identify sudden interruption events in the runtime event data and map them to interruption nodes in the cascaded dependency graph to generate interrupt location information.

[0108] The impact definition module is used to calculate the impact propagation range of the interruption location information in the cascaded dependency graph and extract the affected subgraph to generate the impact boundary subgraph.

[0109] The candidate construction module is used to obtain available capacity data and rule constraint data corresponding to the influence boundary subgraph and construct candidates to generate a candidate link set.

[0110] The feasibility verification module is used to perform feasibility propagation verification based on the candidate link set and the influence boundary subgraph, and generate an executable combination set.

[0111] The reconstruction scoring module is used to calculate and sort the reconstruction scores of the executable combination set, and generate a set of reconstruction schemes.

[0112] The execution monitoring module is used to select a target reconstruction scheme from the set of reconstruction schemes and decompose it into execution actions, generate an execution sequence, send the execution sequence and monitor execution feedback to update the execution status, and generate reconstruction result data.

[0113] It should be noted that the electrical connections between the various units described above do not necessarily represent direct or indirect connections. Any indirect connection method can be applied to the embodiments of the present invention as long as it achieves the purpose of the present invention. The above descriptions are merely exemplary embodiments of the present invention and should not be construed as limiting the scope of the present invention.

[0114] All equivalent changes and modifications made in accordance with the teachings of this invention are still within the scope of this invention. Those skilled in the art will readily conceive of other embodiments of this invention upon considering the specification and the disclosure of practical truth. This application is intended to cover any variations, uses, or adaptations of this invention that follow the general principles of this invention and include common knowledge or conventional techniques in the art not described herein.

Claims

1. A cascaded reconfiguration method for sudden interruptions in multi-segment business travel, characterized in that, The method includes: Acquire trip order data and runtime event data, perform structured parsing, and generate trip structure data; Extract the segment relationships and connection constraints from the itinerary structure data and perform graph modeling to generate a cascaded dependency graph; Identify sudden interruption events in the runtime event data and map them to interruption nodes in the cascaded dependency graph to generate interruption location information; Calculate the impact propagation range of the interruption location information in the cascaded dependency graph and extract the affected subgraph to generate an impact boundary subgraph; Obtain available capacity data and rule constraint data corresponding to the influence boundary subgraph and construct candidates to generate a candidate link set; Based on the candidate link set and the influence boundary subgraph, a feasibility propagation verification is performed to generate an executable combination set; Calculate and sort the refactoring scores for the executable combination set to generate a set of refactoring schemes; Select a target reconstruction scheme from the set of reconstruction schemes and break it down into execution actions, generate an execution sequence, send the execution sequence and monitor execution feedback to update the execution status, and generate reconstruction result data.

2. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generated trip structure data includes: Obtain passenger information, order consistency information, and ticket information from the trip order data, and generate order constraint data; Retrieve the flight segment list, arrival and departure airport information, and scheduled time information from the itinerary order data to generate basic flight segment data; The order constraint data and the flight segment basic data are merged and a consistency check is performed to generate itinerary structure data.

3. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generation of the cascaded dependency graph includes: Extract adjacent flight segments from the itinerary structure data and calculate the transfer time window to generate connection time window constraints; Extract ticket consistency restrictions and cabin class adaptation restrictions from the itinerary structure data to generate ticket and cabin class constraints; Write the connection time window constraint and the ticket cabin class constraint into the flight segment node and connection edge and establish dependency relationship to generate a cascaded dependency graph.

4. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generated interruption location information includes: Obtain flight status change information from runtime event data and normalize the events to generate a candidate set of interruption events; The candidate set of interruption events is matched with the segment nodes of the cascaded dependency graph to generate an event node mapping; Based on the event node mapping, the interrupt type is determined, the interrupt node and the interrupt time are identified, and interrupt location information is generated.

5. The cascaded reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generation of the influence boundary subgraph includes: Based on the interruption location information, the preceding arrival state of the interruption node is extracted and the available connection starting point is calculated to generate the propagation starting point state. Propagate backward along the cascaded dependency graph from the propagation starting state and mark the affected nodes to generate an influence marking graph; Based on the influence marker graph, the connected affected regions that meet the preset conditions are extracted, and the lock markers of unaffected nodes are retained to generate an influence boundary subgraph.

6. The cascaded reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generated candidate link set includes: Obtain available flight information and seat availability information from available capacity data and perform reachability filtering to generate a set of reachable flights; Obtain enterprise travel rules and passenger preference rules from the rule constraint data, encode the rules, and generate rule feature vectors; The set of reachable flights is combined with the rule feature vector, and execution dependency conditions are generated for each combination to generate a set of candidate links.

7. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generation of executable combinatorial sets includes: Based on the influence boundary subgraph and the candidate link set, a propagation state is constructed and the arrival time distribution is initialized to generate an initial propagation state; The candidate links are propagated segment by segment using the initial propagation state, and the ticket consistency state and connection feasibility state are updated to generate a propagation state sequence. Based on the propagation state sequence, candidate combinations that trigger infeasible states are eliminated, and combinations that satisfy all constraints are retained to generate an executable combination set.

8. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The set of generated reconstruction schemes includes: Acquire operational status data and extract fluctuation features from the candidate link set to generate interruption risk features; Based on the executable combination set, the change cost is calculated and the trip deviation feature is calculated to generate the cost deviation feature; By integrating the interruption risk characteristics and the cost deviation characteristics and performing multi-objective sorting, a set of reconstruction schemes is generated.

9. The cascading reconstruction method for sudden interruptions in multi-segment business travel as described in claim 1, characterized in that, The generated reconstruction result data includes: The target reconstruction scheme is decomposed into locking seat action, rescheduling action and ticketing action, and action dependencies are established to generate an execution sequence; Send the execution sequence and receive the action receipt returned by the external system, and generate execution receipt data; The execution status is updated based on the execution receipt data, and when an action failure is detected, a state snapshot of the executed action is extracted, an incremental reconstruction input is generated, and an incremental update of the influence boundary subgraph is triggered, and the reconstruction result data is output.

10. A cascaded reconfiguration system for sudden interruptions in multi-segment business travel, applied to the cascaded reconfiguration method for sudden interruptions in multi-segment business travel as described in any one of claims 1-9, characterized in that, The system includes: The data parsing module is used to acquire trip order data and runtime event data, perform structured parsing, and generate trip structure data; The dependency graphing module is used to extract the segment relationships and connection constraints in the itinerary structure data and perform graph modeling to generate a cascaded dependency graph. An interrupt location module is used to identify sudden interruption events in the runtime event data and map them to interruption nodes in the cascaded dependency graph to generate interrupt location information. The impact definition module is used to calculate the impact propagation range of the interruption location information in the cascaded dependency graph and extract the affected subgraph to generate an impact boundary subgraph. The candidate construction module is used to obtain available capacity data and rule constraint data corresponding to the influence boundary subgraph and construct candidates to generate a candidate link set. The feasibility verification module is used to perform feasibility propagation verification based on the candidate link set and the influence boundary subgraph, and generate an executable combination set. The reconstruction scoring module is used to calculate and sort the reconstruction scores of the executable combination set, and generate a set of reconstruction schemes. The execution monitoring module is used to select a target reconstruction scheme from the set of reconstruction schemes and decompose it into execution actions, generate an execution sequence, send the execution sequence and monitor execution feedback to update the execution status, and generate reconstruction result data.

Images