3.5/3.6哈希表/回文数

题目1：输入一个字母串和一个字符串，要求字符和字母串的规律一样：

# pattern = input()
# s = input()
# num = 0
# s1 = s.split(" ")
# flag = 1
# if len(s1) == len(pattern):
#     for i in range(len(pattern)-1):
#         j = 1+i
#         for j in range(len(s1)):
#             if s1[j] == s1[i]:
#                 if pattern[j] != pattern[i]:
#                     flag = 0
#                     break
#             else:
#                 if pattern[j] == pattern[i]:
#                     flag = 0
#                     break
# else:
#     flag = 0
# if flag == 1:
#     print('true')
# else:
     print('false')
#哈希表解法
def wordpattern(pattern,s):
    s = s.split
    if len(s) == len(pattern):
        return False
    char2word = {}
    word2char = {}
    for c,w in zip(pattern,s):#zip函数将两个列表中的元素一一对应
        if c not in char2word:
            char2word[c] = w
        if w not in word2char:
            word2char[w] = c
            #如果不匹配，返回False

        if char2word[c] != w or word2char[w] != c:#如果不匹配，返回False
            return False

哈希表代码解读：

本题这里简单实现了一下python的哈希表，这里的两个字典
char2word = {}

word2char = {}

分别储存的是以c为q，w为值与w为q，c为值的两个字典，由于在比对两个字符串的字母和单词是否一一对应（双向映射），所以在每一次循环中对比一次两组字典的键值是否与对方的值键相同，若有任意一个不同则说明两组数组没有一一对应即不满足题意，这道题的时间复杂度对比第一钟方法效率高很多。

题目2：不使用数组，判断一个数字是否为回文数

num = int(input())

def huiwen(num):
    a = num
    length = 1
    while (a >= 10):
        a = a // 10
        length += 1
    for i in range(1, length):
        a1 = (num // pow(10, length - i)) % 10  # 获取数字的每一位
        a2 = (num // pow(10, i-1)) % 10
        # print(num,num // pow(10, i-1))

        if a1 != a2:
            return ("no")

    return ("yes")
print(huiwen(num))

这里注意a2 = (num // pow(10, i-1)) % 10需要对i - 1，或者可以直接对 pow(10, i-1)进行取余，这里是使用了回文串的性质，每次去掉最后一位，与前面的位数进行比较

题目3：交换两个相邻的字符，使得输入变为回文数，若不能则输出Impossible

输入的第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)，第二行是一个字符串，长度为N.只包含小写字母
输出最少的交换次数或Impossible
样例输入
5
mamad
样例输出
3

这是一段Python代码，用于计算最少的交换次数，将给定的字符串变成一个回文串。下面对代码进行逐行解释：

python

n = int(input())
pal = list(input())
count = flag = 0
m = n - 1

首先，从输入中读取整数n，表示字符串的长度。然后从输入中读取由小写字母组成的字符串，并将其转换为一个列表。接下来，定义了变量count、flag和m，初始值都为0，用于计数和标记。

python

for i in range(m):
    for k in range(m, i - 1, -1):
        if k == i:
            if n % 2 == 0 or flag == 1:
                print('Impossible')
                exit()
            flag = 1
            count += int(n / 2) - i
        elif pal[k] == pal[i]:
            for j in range(k, m):
                pal[j], pal[j + 1] = pal[j + 1], pal[j]
                count += 1
            m -= 1
            break

接下来，使用两个嵌套的循环来遍历字符串，比较字符之间的关系。外层循环从头开始遍历到倒数第二个字符，内层循环从后面往前遍历，直到找到与当前字符相同的字符或者遍历到了当前字符的位置。如果找不到相同字符，则进行如下判断：

• 如果字符串的长度为偶数或者已经存在一个单独的奇数次出现的字符，那么无法构成回文，输出"Impossible"，并退出程序。
• 如果当前字符是一个单独的奇数次出现的字符，将flag标记为1，并累加交换次数，计算方式为(n // 2 - i)，n为字符串长度。
  如果找到了相同字符，使用内层循环中的索引对字符串进行交换，将相同字符移到正确的位置上，同时累加交换次数。然后将m减1，因为最后一个字符已经排好序了，可以不再进行比较。

python

print(count)

最后，输出累计的交换次数，即为最少的交换次数。

这段代码的思想是通过遍历字符串，不断寻找相邻字符进行交换，直到将所有不满足成对出现的字符移到正确的位置上，达到构成回文串的要求。