思路：哈希表

我们可以创建两个哈希表，一个用于存储单个字符的中心对称字符，另一个用于存储一对字符的中心对称字符。然后，我们从字符串的两端开始，逐个比较字符。

如果两个字符相等，我们检查这个字符是否在单个字符的哈希表中。如果不在，那么这个字符串就不满足原封不动的性质。

如果两个字符不相等，我们创建一个新的字符串，包含这两个字符，并将其排序。然后，我们检查这个新字符串是否在一对字符的哈希集中。如果不在，那么这个字符串就不满足原封不动的性质。

代码

C++

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
string s;
int T,n;
unordered_set<char>st={'o','x','s','z'};  //单个字符
unordered_set<string>mp={"dp","bq","nu"};  //一对字符
void solve(){
    cin>>s;
    n=s.size();
    int i=0,j=n-1;
    while(i<=j){
        if(s[i]==s[j]){
            if(!st.count(s[i])){  //相等的话 必须要求本身是中心对称的
                puts("no");
                return;
            }
        }
        else{
            string t;
            t.push_back(s[i]);t.push_back(s[j]);
            sort(t.begin(),t.end());
            if(!mp.count(t)){
                puts("no");
                return;
            }
        }
        i++;j--;
    }
    puts("yes");
}
int main() {
    cin>>T;
    while(T--){
        solve();
    }
    return 0;
}

Java

import java.util.*;

class Main {

    static HashMap<Character, Character> hm = new HashMap<>();


    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        sc.nextLine();
        String[] strs = new String[n];
        for (int i = 0; i < n; i++) {
            strs[i] = sc.nextLine();
        }

        hm.put('u', 'n');
        hm.put('n', 'u');
        hm.put('w', 'm');
        hm.put('m', 'w');
        hm.put('p', 'd');
        hm.put('d', 'p');
        hm.put('x', 'x');
        hm.put('o', 'o');
        hm.put('q', 'b');
        hm.put('b', 'q');


        for (String s : strs) {
            int left = 0, right = s.length() - 1;
            if(isvaild(s, left, right)){
                System.out.println("yes");
            }else{
                System.out.println("no");
            }
        }
    }

    private static boolean isvaild(String s, int left, int right) {

        while (left <= right) {
            char leftChar = s.charAt(left);
            char rightChar = s.charAt(right);

            if (!hm.containsKey(leftChar) || hm.get(leftChar) != rightChar) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

python

T = int(input())
MAP = {
    "n":"u",
    "u":"n",
    "w":"m",
    "m":"w",
    "p":"d",
    "d":"p",
    "x":"x",
    "o":"o",
    "q":"b",
    "b":"q"
}
def judge(s):
    l,r = 0,len(s)-1
    while l<r:
        if s[l] not in MAP or s[r] not in MAP or MAP[s[l]]!=s[r]:
            return "no"
        l+=1
        r-=1
    if l==r and MAP[s[l]]!=s[l]:
        return "no"
    return "yes"

res = []
for _ in range(T):
    s = input().strip()
    # print()
    res.append(judge(s))

print("\n".join(res))

题目描述

原XX动，这是一道让人难以回答的填空题，但是塔子一眼就看出了答案——原封不动！字符串的原封不动定义为：以字符串的中心为旋转中心，将整个字符串旋转180°后仍与原来保持一致，比如 "pxd"，塔子为了拖延你的刷委托进度，设置了T个字符串，你需要回答它们是否具有原封不动的性质。答对了没有奖励，但是答错了可是有惩罚的哟~，今天的委托就要牡蛎了（大悲）。。。

关于中心对称：

n , u

w , m

p , d

x , x

o , o

q , b

他们之间都是中心对称的

输入描述

第一行有一个数字，T，表示样例的总组数 $(1\le T\le10^5)$，接下来T行每行输入一个字符串表示询问。数据保证字符串总长度不超过 $10^6$

输出描述

输出T行，每行输出"yes”或“no”表示字符串是否中心对称。

样例

输入

2
pund
puq

输出

yes
no

Limitation

1s, 1024KiB for each test case.