Java實現基于后綴樹的回文串子串查找

在Java中實現基于后綴樹的回文串子串查找，首先需要構建一個后綴樹，然后利用這個后綴樹來查找回文串

import java.util.*;

class SuffixTreeNode {
    int start, end;
    Map<Character, SuffixTreeNode> children;

    public SuffixTreeNode() {
        start = -1;
        end = -1;
        children = new HashMap<>();
    }
}

public class SuffixTree {
    private SuffixTreeNode root;
    private String text;

    public SuffixTree(String text) {
        this.text = text;
        buildSuffixTree();
    }

    private void buildSuffixTree() {
        int n = text.length();
        root = new SuffixTreeNode();
        for (int i = 0; i < n; i++) {
            insert(text.substring(i));
        }
    }

    private void insert(String suffix) {
        SuffixTreeNode node = root;
        for (char c : suffix.toCharArray()) {
            if (!node.children.containsKey(c)) {
                node.children.put(c, new SuffixTreeNode());
            }
            node = node.children.get(c);
        }
        node.end = suffix.length() - 1;
    }

    public List<Integer> searchPalindrome(String palindrome) {
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < text.length(); i++) {
            if (isPalindrome(text, i, i + palindrome.length() - 1)) {
                result.add(i - palindrome.length() + 1);
            }
        }
        return result;
    }

    private boolean isPalindrome(String text, int start, int end) {
        while (start < end) {
            if (text.charAt(start) != text.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }

    public static void main(String[] args) {
        String text = "banana";
        SuffixTree suffixTree = new SuffixTree(text);
        String palindrome = "ana";
        List<Integer> result = suffixTree.searchPalindrome(palindrome);
        System.out.println("Palindrome found at positions: " + result);
    }
}

這個程序首先構建了一個后綴樹，然后通過searchPalindrome方法查找給定的回文串子串在文本中的所有位置。isPalindrome方法用于檢查一個字符串是否為回文串。

注意：這個實現僅適用于較短的文本，因為構建后綴樹的時間復雜度為O(n^2)，其中n為文本長度。對于較長的文本，可以考慮使用更高效的算法，如Manacher算法。