备战蓝桥杯22弹

第一题

class Solution {
    public boolean isPalindrome(ListNode head) {
        List<Integer> vals=new ArrayList<Integer>();

        ListNode currentNode=head;
        while(currentNode!=null){
            vals.add(currentNode.val);
            currentNode=currentNode.next;
        }

        int front=0;
        int back=vals.size()-1;
        while(front<back){
            if(!vals.get(front).equals(vals.get(back))){
                return false;
            }
            front++;
            back--;
        }
        return true;
    }


}

思路：首先将链表里的数据都存到列表中，然后用前后两个指针从两端遍历直至相遇，遍历过程中如果两个指针所指的元素不同，直接返回false，遍历完成后满足要求的话，返回true。 

第二题

class Solution {
    private final List<List<String>> ans = new ArrayList<>();
    private final List<String> path = new ArrayList<>();
    private String s;

    public List<List<String>> partition(String s) {
        this.s = s;
        dfs(0, 0);
        return ans;
    }

    private boolean isPalindrome(int left, int right) {
        while (left < right)
            if (s.charAt(left++) != s.charAt(right--))
                return false;
        return true;
    }

    // start 表示当前这段回文子串的开始位置
    private void dfs(int i, int start) {
        if (i == s.length()) {
            ans.add(new ArrayList<>(path)); // 固定答案
            return;
        }

        // 不选 i 和 i+1 之间的逗号（i=n-1 时右边没有逗号）
        if (i < s.length() - 1)
            dfs(i + 1, start);

        // 选 i 和 i+1 之间的逗号
        if (isPalindrome(start, i)) {
            path.add(s.substring(start, i + 1));
            dfs(i + 1, i + 1);
            path.remove(path.size() - 1); // 恢复现场
        }
    }
}

 

第三题

class Solution {
    public int primePalindrome(int n) {
        int num=0;
        for(int i=n;i<100;i++){
            if(huiwen(i)&&sushu(i)){
                num=i;
                break;
            }

        }
        return num;
    }
    public boolean huiwen(int n){
        String s=String.valueOf(n);
        String s1="";
        for(int i=s.length()-1;i>=0;i--){
            s1+=s.charAt(i);
        }
        return s.equals(s1);

    }
    public boolean sushu(int n){
        for(int i=2;i<n;i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }
}

思路：暴力算法，直接遍历大于n的合适数字，判断其是否回文，是否为素数。