Counting Distinct Square Substrings in Sublinear Time
Fuente:
arXiv
Enregistré dans:
| Auteurs principaux: | , , , , , |
|---|---|
| Format: | Preprint |
| Publié: |
2025
|
| Sujets: | |
| Accès en ligne: | |
| Tags: |
Ajouter un tag
Pas de tags, Soyez le premier à ajouter un tag!
|
| _version_ | 1866915474275565568 |
|---|---|
| author | Charalampopoulos, Panagiotis Mohamed, Manal Radoszewski, Jakub Rytter, Wojciech Waleń, Tomasz Zuba, Wiktor |
| author_facet | Charalampopoulos, Panagiotis Mohamed, Manal Radoszewski, Jakub Rytter, Wojciech Waleń, Tomasz Zuba, Wiktor |
| contents | We show that the number of distinct squares in a packed string of length $n$ over an alphabet of size $σ$ can be computed in $O(n/\log_σn)$ time in the word-RAM model. This paper is the first to introduce a sublinear-time algorithm for counting squares in the packed setting. The packed representation of a string of length $n$ over an alphabet of size $σ$ is given as a sequence of $O(n/\log_σn)$ machine words in the word-RAM model (a machine word consists of $ω\ge \log_2 n$ bits). Previously, it was known how to count distinct squares in $O(n)$ time [Gusfield and Stoye, JCSS 2004], even for a string over an integer alphabet [Crochemore et al., TCS 2014; Bannai et al., CPM 2017; Charalampopoulos et al., SPIRE 2020]. We use the techniques for extracting squares from runs described by Crochemore et al. [TCS 2014]. However, the packed model requires novel approaches.
We need an $O(n/\log_σn)$-sized representation of all long-period runs (runs with period $Ω(\log_σn)$) which allows for a sublinear-time counting of the -- potentially linearly-many -- implied squares. The long-period runs with a string period that is periodic itself (called layer runs) are an obstacle, since their number can be $Ω(n)$. The number of all other long-period runs is $O(n/\log_σn)$ and we can construct an implicit representation of all long-period runs in $O(n/\log_σn)$ time by leveraging the insights of Amir et al. [ESA 2019]. We count squares in layer runs by exploiting combinatorial properties of pyramidally-shaped groups of layer runs. Another difficulty lies in computing the locations of Lyndon roots of runs in packed strings, which is needed for grouping runs that may generate equal squares. To overcome this difficulty, we introduce sparse-Lyndon roots which are based on string synchronizers [Kempa and Kociumaka, STOC 2019]. |
| format | Preprint |
| id |
arxiv_https___arxiv_org_abs_2508_03930 |
| institution | arXiv |
| publishDate | 2025 |
| record_format | arxiv |
| spellingShingle | Counting Distinct Square Substrings in Sublinear Time Charalampopoulos, Panagiotis Mohamed, Manal Radoszewski, Jakub Rytter, Wojciech Waleń, Tomasz Zuba, Wiktor Data Structures and Algorithms We show that the number of distinct squares in a packed string of length $n$ over an alphabet of size $σ$ can be computed in $O(n/\log_σn)$ time in the word-RAM model. This paper is the first to introduce a sublinear-time algorithm for counting squares in the packed setting. The packed representation of a string of length $n$ over an alphabet of size $σ$ is given as a sequence of $O(n/\log_σn)$ machine words in the word-RAM model (a machine word consists of $ω\ge \log_2 n$ bits). Previously, it was known how to count distinct squares in $O(n)$ time [Gusfield and Stoye, JCSS 2004], even for a string over an integer alphabet [Crochemore et al., TCS 2014; Bannai et al., CPM 2017; Charalampopoulos et al., SPIRE 2020]. We use the techniques for extracting squares from runs described by Crochemore et al. [TCS 2014]. However, the packed model requires novel approaches. We need an $O(n/\log_σn)$-sized representation of all long-period runs (runs with period $Ω(\log_σn)$) which allows for a sublinear-time counting of the -- potentially linearly-many -- implied squares. The long-period runs with a string period that is periodic itself (called layer runs) are an obstacle, since their number can be $Ω(n)$. The number of all other long-period runs is $O(n/\log_σn)$ and we can construct an implicit representation of all long-period runs in $O(n/\log_σn)$ time by leveraging the insights of Amir et al. [ESA 2019]. We count squares in layer runs by exploiting combinatorial properties of pyramidally-shaped groups of layer runs. Another difficulty lies in computing the locations of Lyndon roots of runs in packed strings, which is needed for grouping runs that may generate equal squares. To overcome this difficulty, we introduce sparse-Lyndon roots which are based on string synchronizers [Kempa and Kociumaka, STOC 2019]. |
| title | Counting Distinct Square Substrings in Sublinear Time |
| topic | Data Structures and Algorithms |
| url | https://arxiv.org/abs/2508.03930 |