A k-tuple common substring (abbr. k-CSS) is a common subsequence of two or more strings including at most k common substrings. In this paper, we present an algorithm for finding a longest k-CSS of two strings of lengths m and n in O(kmn) time and O(m + kn) space. Using this algorithm as a subroutine, a longest k-CSS of two circular strings is retrieved in O(kmn2) time and O(m + kn) space. Extending the idea in this algorithm, a longest common subsequence with the minimum number of common substrings of two strings is retrieved in O(mn) time and O(m + n) space.

Reciprocal translocation is an important genome rearrangement operation that involves swapping non-empty terminal segments between two chromosomes. Given two multi-chromosomal genomes, A and B, the problem of sorting by reciprocal translocations aims to find the shortest sequence of reciprocal translocations that can transform A into B. This problem can be solved in polynomial time, and, as far as we know, the best time complexity is O(n^3/2√(log n)) . In this paper, by leveraging the results on the fully dynamic graph connectivity problem, we improve the time complexity to O(n(N^2log n+log ^2n)/loglog n) , where n represents the number of genes and N represents the number of chromosomes. In real evolutionary scenarios, the number of chromosomes involved in rearrangement events is typically small. Consequently, when N is treated as a constant or a polynomial function of log n , our algorithm achieves a time complexity better than O(n^3/2√(log n)) .

A (k]-tuple common substring is a sequence of at most k common substrings of two or more strings. Motivated by computational biology applications, we propose to find between two strings a longest (k]-CSS(l1, l2), that is a longest (k]-tuple common substring in which each substring is of length in [l1, l2]. We present a sliding window based dynamic programming algorithm to find a longest (k]- CSS(l1, l2) of two strings whose lengths are n1 and n2 in O(kn1n2) time and space, the same complexity as without the length bounds l1 and l2. We present a divide-and-conquer algorithm to find a longest (k]-CSS(l1, l2) in O(kn1n2) time and O(n1 + kl2n2) space, allowing much longer strings to be input for solution retrieval. We also present an algorithm to find a longest (2]-CSS(l1, l2) of two strings of total length n in O(nlog2 n) time.

In this paper, we investigate the twin bridges problem in polygons, whose counterpart on trees has been studied recently. Given two disjoint simple polygons P and Q, each with at most n vertices, the problem is to find two vertices p_1 and p_2 in P (and q_1 and q_2 in Q) to build two bridges p_1q_1 and p_2q_2 such that the constrained diameter of the resulting geometric structure (e.g., a polygon with a hole when the two bridges do not intersect), i.e., the maximum of the shortest distance between two vertices in P, Q, or just in one of them, through at least one of the bridges, is minimized. The main results are summarized as follows: (1) If P and Q are arbitrary polygons, the problem can be solved in O(n^6log n) time. (2) These results hold even if the bridges between p_i and q_i , i∈{1,2} , are geodesic. (3) We show the general problem is NP-hard: given m disjoint polygons P_1,...,P_m , add two bridges between P_i and P_i+1 , i∈ [m-1] , such that the constrained diameter of the resulting geometric structure (ideally, a polygon with multiple holes, but could be more complex if some of the bridges intersect) is minimized.

Double cut and join (abbreviated as DCJ) is a popular rearrangement operation, and the problem of sorting permutations by DCJs can be used to approximately estimate the evolutionary distance between two genomes. Although this problem has been widely studied, most of the existing work on sorting permutations by DCJs didn't consider repeats around the breakpoints. Recent studies revealed that the breakpoints of rearrangement events are closely related to repetitive segments. To better mimic the rearrangement operations between genomes in reality, here we present a new rearrangement model called flanked DCJ, which requires the two breakpoints of a DCJ to be cut at the same relative side of a pair of repeats. We first investigate the decision problem of sorting signed permutations by flanked DCJs, which asks to check if a genome can be transformed into another by a series of flanked DCJs, and give an O(n(2)) time decision algorithm. Then, for the optimization version of sorting signed permutations by the minimum flanked DCJs, we show that it can be solved in O(n(2)) when each repeat appears at most three times, and prove the NP-hardness of the general case.

A (k]-tuple common substring (abbr. (k]-CSS) is a common subsequence of multiple given strings including at most k common substrings. This pattern of two strings is retrievable in quadratic time and linear space and even more, in subquadratic time and space if k is a constant. Motivated by computational biology applications in need of a (k]-CSS with substantially many consecutive matches, we propose to find a longest (k]-CSS of two strings whose substrings are of length at least l, of which the complexity is indefinite. We present a dynamic programming algorithm to find such a longest (k]CSS of two strings whose lengths are n(1) and n(2) in O(kn(1)n(2)) time and space, the same complexity as without the length bound l. Through rolling array based dynamic programming to get the longest (k]-CSS length in advance, we present a divide-and-conquer algorithm to find such a longest (k]-CSS in O(kn(1)n(2)) time and O(n(1) + kln(2)) space, which is intended to work for two much longer given strings. We also present an algorithm to find such a longest (2]-CSS in O(nlog(2)n) time where n is the total length of input strings.

The analysis of genomes evolving by inversions has led to a famous problem of sorting a permutation by reversals. On the other hand, during the evolution of many genomes, the involvement of repeated segments is unavoidable, which has inspired new interests on the model of sorting by signed/unsigned symmetric reversals. Recently, the signed version of this problem has been investigated. In this paper, we focus on the problem of Sorting by Unsigned Symmetric Reversals, which requires a series of unsigned symmetric reversals to transform a chromosome.A into chromosome.B, where chromosomes are represented by a sequence of unsigned symbols (possibly with repetitions). Our main result is on the special case where each symbol appears at most twice in a chromosome. We give a sufficient and necessary condition to answer the decision problem, and design an algorithm with approximation factor 1.5 for the corresponding optimization problem, which runs in O(n(4)) time.

Computing the genome rearrangement distances between two genomes has been classical combinatorial optimization problems since the 1990s, where reversals, translocations and double cut and joins (dcjs for short) are the most popular genome rearrangement operations. All the three distances can be computed in polynomial time for signed genomes but are NP-hard when the genomes are unsigned. Over the past three decades, people devoted to approximation algorithms for the three problems. So far as we know, the best approximation ratio is 1.375 for both reversal and translocation, and 1.408 for dcj. In this paper, we first design a proper approximation algorithm for the maximum independent set problem on graphs with a maximum degree of 3, by use of which, we devise an approximation algorithm for the unsigned dcj problem, improving the approximation ratio to 4173/3035 (≈ 1.37496 ) + ε , and running in O(n^3+4log4+5log5/ε) , where n represents the length of the genomes and ε is an arbitrary small constant. Joined with the pre-processing method for the unsigned reversal problem and unsigned translocation problem respectively in [5, 16], our algorithm can also be extended to solve the unsigned reversal problem and the unsigned translocation problem, also guaranteeing the same approximation ratio of 4173/3035 , beating the long-lasting best ratio of 1.375 since 2002.

A (k]-tuple common substring (abbr. (k]-CSS) is a sequence of at most k common substrings of two or more strings. A longest (k]-CSS of two strings is known retrievable in quadratic time and linear space and even more, in subquadratic time and space if k is a constant. Motivated by computational biology applications in need of a (k]-CSS with designated number of consecutively matching letters, we propose to find a longest (k]-CSS of two strings whose substrings are of length within [l(1), l(2)]. We present a sliding window based dynamic programming algorithm to find such a longest (k]-CSS of two strings whose lengths are n(1) and n(2) in O(kn(1)n(2)) time and space, the same complexity as without the length bounds l(1) and l(2). Through rolling array based dynamic programming to get the longest (k]-CSS length in advance, we present a divide-and-conquer algorithm to find such a longest (k]-CSS in O(kn(1)n(2)) time and O(n(1) + kl(2)n(2)) space, which is intended to work for two much longer given strings. We also present an algorithm to find such a longest (2]-CSS in O(n log(2) n) time where n is the total length of input strings.

It is widely recognized that structural variation represents a significant source of genetic variation. As a well-known type of structural variation, reversion is studied drastically by both biologists and computer scientists. Recently, scientists have found that repetitive sequences always appear at the ends of the segment where the reversal occurred on the chromosome, which has inspired new interests in models for sorting unsigned chromosomes by symmetric reversals (abbreviated MUSR). The problem of MUSR asks for a minimum number of unsigned symmetric reversals to transform a chromosome S into another chromosome T, and requires symmetric reversals to be performed on the segment flanked by the same letter. In this paper, we show that MUSR is NP-hard through an intricate reduction from the MAX-(3,B2)-SAT problem. Moreover, we provide an innovative depiction of the optimal solution and then develop an improved approximation algorithm that ensures the approximation factor of 2 ln3+7/8 (approximately 1.15) and a time complexity of O(n(2)).

Comparing genomes based on gene order is a classical combinatorial optimization problem in computational biology, which seeks the minimum number of genome rearrangement operations required to transform one genome into another. The problem of sorting genomes by translocations has been extensively studied over the past few decades. Computing the translocation distance is NP-hard when the input genomes are unsigned, posing significant computational challenges. A widely adopted approach to approximating this problem involves decomposing the breakpoint graph into proper alternating cycles. However, this decomposition step becomes a bottleneck in calculating the corresponding rearrangement distances, hindering the ability to achieve approximation factors better than 1.375 in polynomial time. In this paper, we propose a novel FPT (fixed-parameter tractable) approximation algorithm for the problem of sorting genomes by translocations, improving the approximation factor to 4/3 + ε , thereby surpassing the long-standing best ratio of 1.375, which has held since 2016 [12]. Our algorithm employs a new randomized method for decomposing the breakpoint graph, which succeeds with high probability, 1 - 1/e^O(n) , as guaranteed by the Chernoff Bound. The time complexity of the algorithm is O(2^d^*· n^O(1/ϵ)) , where n represents the length of each genome and d^* denotes the optimal translocation distance.

Transposition is a well-known genome rearrangement event that switches two consecutive sub-strings on a string. Since a transposition makes changes to a string, the genome here is just a string. The problem of transforming one string into the other by a sequence of transposition operations has attracted a lot of attention. However, it has been reported that genome rearrangement events are often associated with repeated sub-strings. In particular, a transposition operation is most likely associated with three identical repeated sub-strings. A transposition operation on two consecutive sub-strings $x$ and $y$ switches the two sub-strings and transforms the whole string $zxyw$ into the other string $zyxw$, where $z$ and $w$ represents the two sub-strings on the left and right of $xy$, respectively. When repeated sub-strings are considered, the two consecutive sub-strings $x$ and $y$ are flanked with three identical repeated sub-strings $R$ and the flanked transposition transforms the whole string $zRxRyRw$ into $zRyRxRw$. For a flanked transposition operation, the neighbors of $x$ and $y$ remain the same before and after the transposition. In this paper, we investigate the problem of transforming one string into the other by a number of flanked transpositions. First, we present a necessary and sufficient condition to determine if a string can be transformed into the other by a sequence of flanked transpositions. We then design a decision algorithm with running time $\mathcal {O}(n)$ to test if such a condition holds. We also show that transforming one string into the other by using minimum number of flanked transpositions is NP-hard. A string $\pi$ of $n$ letters is simple if the $n-1$ consecutive pairs of letters are distinct. We present an $\mathcal {O}(n^{2})$ approximation algorithm with ratio 2 for the optimization version of the special case, where both input strings are simple.

Rearrangement sorting problems impact profoundly in measuring genome similarities and tracing historic scenarios of species. However, recent studies on genome rearrangement mechanisms disclosed a statistically significant evidence, repeats are situated at the ends of rearrangement relevant segments and stay unchanged before and after rearrangements.To reflect the principle behind this evidence, we propose flanked block-interchange, an operation on strings that exchanges two substrings flanked by identical left and right symbols in a string. The flanked block-interchange distance problem is formulated as finding a shortest sequence of flanked block-interchanges to transform a string into the other. We propose a sufficient and necessary condition for deciding whether two strings can be transformed into each other by flanked block-interchanges. This condition is linear time verifiable. Under this condition for two strings, we present a $\text{4}\,k$4k-approximation algorithm for the flanked block-interchange distance problem where each symbol occurs at most $k$k times in a string and a polynomial algorithm for this problem where each symbol occurs at most twice in a string. We show that the problem of flanked block-interchange distance is NP-hard at last.

This paper investigates two combinatorial problems from RNA secondary structure prediction with arbitrary pseudoknots. Given a RNA sequence and a set of base pairs, two parallel and adjacent base pairs constitute a stacking. The Maximum Stacking Base Pairs problem (MSBP) aims at finding a maximum number of based pairs, all of which form stackings, while the Maximum Base Pair Stackings problem (MBPS) is to find a maximum number of stackings. Both problems are NP-hard. We present two new approximation algorithms for the two problems by local search methods. For MSBP, the approximation factor is improved from 52 to 73; as for the MBPS, the approximation factor is improved from 83 to 52.

Recent advancements in AI-based synthesis of small molecules have led to the creation of extensive databases, housing billions of small molecules. Given this vast scale, traditional quantum chemistry (QC) methods become inefficient for determining the chemical and physical properties of such an extensive array of molecules. To address this challenge, we present MetaGIN, a lightweight deep learning framework designed for efficient and accurate molecular property prediction. While traditional GNN models with 1-hop edges (i.e., covalent bonds) are sufficient for abstract graph representation, they are inadequate for capturing 3D features. Our MetaGIN model shows that including 2-hop and 3-hop edges (representing bond and torsion angles, respectively) is crucial to fully comprehend the intricacies of 3D molecules. Moreover, MetaGIN is a streamlined model with fewer than 10 million parameters, making it ideal for fine-tuning on a single GPU. It also adopts the widely acknowledged MetaFormer framework, which has consistently shown high accuracy in many computer vision tasks. In our experiments, MetaGIN achieved a mean absolute error (MAE) of 0.0851 with just 8.87M parameters on the PCQM4Mv2 dataset, outperforming leading techniques across several datasets in the MoleculeNet benchmark. These results demonstrate MetaGIN’s potential to significantly accelerate drug discovery processes by enabling rapid and accurate prediction of molecular properties for large-scale databases.

We focus on a new problem that is formulated to find a longest k-tuple of common sub-strings (abbr. k-CSSs) of two or more strings. We present a suffix tree based algorithm for this problem, which can find a longest k-CSS of m strings in $O(kmn^{k})$ time and $O(kmn)$ space where n is the length sum of the m strings. This algorithm can be used to approximate the longest k-CSS problem to a performance ratio $\frac{1}{\epsilon}$ in $O(kmn^{\lceil\epsilon k\rceil})$ time for $\epsilon\in(0,1]$. Since the algorithm has the space complexity in linear order of n, it will show advantage in comparing particularly long strings. This algorithm proves that the problem that asks to find a longest gapped pattern of non-constant number of strings is polynomial time solvable if the gap number is restricted constant, although the problem without any restriction on the gap number was proved NP-Hard. Using a C++ tool that is reliant on the algorithm, we performed experiments of finding longest 2-CSSs, 3-CSSs and 5-CSSs of 2 ~ 14 COVID-19 S-proteins. Under the help of longest 2-CSSs and 3-CSSs of COVID-19 S-proteins, we identified the mutation sites in the S-proteins of two COVID-19 variants Delta and Omicron. The algorithm based tool is available for downloading at https://github.com/lytt0/k-CSS.

Order-consistent and number-limited common substrings of multiple strings are in strong demand for conserved region recognition and structural similarity identification in bio-sequences. To characterize order-consistent and number-limited common substrings, we propose (k]-tuple common substring (abbr. (k]-CSS), a sequence of no more than k non-overlapping common substrings of two or more strings. This paper is devoted to designing algorithms to solve a problem called LCSS(m,k) that asks to find a longest (k]-CSS of m ≥ 2 strings. For LCSS(m,k), we present a suffix tree based algorithm to find a longest (k]-CSS of m strings in O(mn^k) time and O(kmn) space where n is the length sum of m given strings. This algorithm can be used to approximate LCSS(m,k) to achieve a performance 1/ε for ε∈(0,1] in O(mn^⌈εk⌉ ) time. For LCSS(2,k), we present a dynamic programming algorithm to find a longest (k]-CSS of two strings in O(kn_1 n_2) time and space where n_1 and n_2 are the lengths of the given strings. To break through the quadratic space limitation, we present to improve the algorithm for LCSS(2,k) to run in O(kn_1 n_2) time and O(n_1+kn_2) space.

The turnover number (k cat ) is a crucial measure for evaluating enzyme catalytic efficiency, significantly influencing studies of cellular metabolism and resource allocation. Due to the high costs associated with determining k cat , predictive machine learning models such as TurNuP have been developed to predict the turnover numbers of kinetically uncharacterized enzymes. Existing methods rely on binary Differential Reaction Fingerprints (DRFPs) to represent reactions. However, these binary reaction fingerprints have two main limitations. First, they only show changes between substrates and products, without specifying whether the change occurs in the substrates or products. Second, they omit information about similarities between substrates and products, missing crucial reaction details. To overcome these issues, we developed Quaternary Reaction Fingerprints (QRFPs) by incorporating quaternary structural features. Thus, QRFPs extend DRFPs, and DRFPs can be derived from QRFPs. We proposed a deep learning method based on QRFPs and pretrained protein language model ESM2, called TurNuP 4 . Experimental results show that TurNuP 4 outperforms TurNuP by 18% in R 2 to predict k cat values for natural reactions of wild-type enzymes. Code is available at https://github.com/xfcui/TurNuP4.

The protein-ligand affinity prediction task aims to predict the binding strength of small molecule ligands to specific proteins, which is crucial in the fields of drug design and molecular biology, and can accelerate the drug discovery. The structure complementarity between protein and ligand plays a critical role in determining binding strength , but most of current deep learning-based affinity prediction models usually extracted the features of protein and ligand by these two detached modules. which limits the exchange of information for capturing interactions and struggles to capture proteins’ important residues. To address these limitations. we introduce CIP. which takes the combination of GNN, Conditional Updating and Proximity Embedding for the first time. Compared to existing models, CIP has several significant advantages. First, Conditional updating modifies the ligand’s local features based on the protein’s global features, and vice versa , enhancing structural complementarity to capture intricate interactions. Second, encoding the relative distances between proximal residue-atom pairs highlights critical residues. Additionally, our model integrates covalent and noncovalent interactions to obtain more comprehensive graph representations. Experiments on the PDB-bind 2016 benchmark demonstrate that CIP outperforms the original method with improvements of 2.3%, 3.2%, 2.8%, 3.8%, and 3.2% across five baselines. Furthermore, visualization results reveal that CIP effectively captures intricate interactions and crucial residues.The implemented code and dataset are available online at https://github.com/xfcui/CIP.

Shortest Common Supersequence (SCS) is a well-known problem in string algorithms and related applications. For multiple input sequences the problem is NP-hard and for a fixed number of d input sequences it can be solved in O(n^d) time, where n is the maximum length of the input sequences. In this paper, we consider designing parameterized algorithms or proving the non-existence of these algorithms for SCS and several of its variants.