L2-4 秀恩爱分得快（python实现）

Luxmlb

已于 2023-04-15 20:41:20 修改

阅读量131

点赞数

文章标签：算法数据结构 python

于 2023-04-10 21:57:37 首次发布

本文链接：https://blog.csdn.net/Luxmlb/article/details/130070424

版权

#encoding=utf-8
def binary_serch(nums, target):
    i = 0
    j = len(nums) - 1
    m = -1
    while i <= j:
        m = (i + j) // 2
        if target == nums[m]:
            return m
        elif target > m:
            i = m + 1
        else:
            j = m - 1

#变量的声明
flag_A=0
flag_B=0
# 控制输入
N, M = map(eval, input().split())

# 准备一个照片集p
p = []
for i in range(M):
    p.append(list(map(eval, input().split())))
A, B = map(eval, input().split())
# 判断A，B的正负性(应该没有gay吧.....)
if A > 0:
    judge_A = 1
    judge_B = 0
else:
    judge_A = 0
    judge_B = 1

# 建立A,B的hash字典（为了方便起见（我是直接对着例子进行分析的，所以我命名的规则就是按照给的实例一命名的））
hashmap_A = dict()
hashmap_B = dict()
# 循环遍历照片集p
for i in p:
    # 首先要对i进行排序(从小到大或者从大到小应该没那么严格的要求)，排完序之后再进行二分查找
    # n表示i照片的第一个元素——也就是照片中的人数（pop出来再排序懂得都懂）
    n = i.pop(0)
    sorted(i, reverse = True)

    # 二分查找i中是否有A,B，因为我们最后需要判断的A,B相对应的关系，所以这样可以减少无关数据的判断
    # 用m_A来记录找到的A的下标 用m_B来记录找到的B的下标
    m_A = binary_serch(i, A)
    m_B = binary_serch(i, B)

    # 如果m_A和m_B的值不为none也就是找到了那么就弹出A和B
    if m_A != None:
        i.pop(m_A)
        flag_A=1
    # 否则我们就可以不用查找关于A的异性了（A都没在里面，当然对于A来说这张照片中其他人就是无效数据了）
    if m_B != None:
        i.pop(m_B)
        flag_B=1
    # 然后开始查找i中相应的负数和正数对应的添加到A,B的hash字典中去
    for k in i:
        # 如果A在i里面而且 A是正数的话，那我们就去i中找负数，而且找到的负数添加到A的hash字典中去
        if flag_A and judge_A>0:
            if k < 0:
                hashmap_A[k] = hashmap_A.get(k, 0) + 1 / n
        if flag_B and judge_B>0:
            if k < 0:
                hashmap_B[k] = hashmap_A.get(k, 0) + 1 / n
        if flag_A and  judge_A<0:
            if k > 0:
                hashmap_A[k] = hashmap_B.get(k, 0) + 1 / n
        if flag_B and  judge_B<0:
            if k > 0:
                hashmap_B[k] = hashmap_B.get(k, 0) + 1 / n
# 然后开始查找两个hashmap中的max
# 首先进行排序
l_hashmap_A = list(hashmap_A.items())
s_l_A = sorted(l_hashmap_A, key=lambda x: x[1], reverse=True)
# 然后返回排序后的第一个值也就是max
max_l_A = s_l_A[0][1]
l_hashmap_B = list(hashmap_B.items())
s_l_B = sorted(l_hashmap_B, key=lambda x: x[1], reverse=True)
max_l_B = s_l_B[0][1]

# 然后到两个字典里面去找max对应的key并分别返回一个最大值列表，
# 如果A,B同时都是二者最大值列表中的值，输出一行就可以了
# 如果并没有那么就分别输出就可以了
maxlistA = []
maxlistB = []
for i in hashmap_A.items():
    if i[1] == max_l_A:
        maxlistA.append(i[0])
for i in hashmap_B.items():
    if i[1] == max_l_B:
        maxlistB.append(i[0])

#然后二分查找两个最亲密关系中是不是有对方
A_beleave=binary_serch(maxlistA,B)
B_beleave=binary_serch(maxlistB,A)
if A_beleave is not None and B_beleave is not None:
    print("{} {}".format(A, B))
# 按照绝对值从小到大输出
else:
    maxlistA2 = sorted(maxlistA, key=abs, reverse=True)
    maxlistB2 = sorted(maxlistA, key=abs, reverse=True)
    for i in maxlistA2:
        print("{} {}".format(A, i))
    for i in maxlistB2:
        print("{} {}".format(B, i))

无语。。。。。。

这个报错不知道怎么了，我明明没有改这行代码，原来逻辑有误的代码如下：都没报这个错误

#encoding=utf-8
def binary_serch(nums, target):
    i = 0
    j = len(nums) - 1
    m = -1
    while i <= j:
        m = (i + j) // 2
        if target == nums[m]:
            return m
        elif target > m:
            i = m + 1
        else:
            j = m - 1


# 控制输入
N, M = map(eval, input().split())

# 准备一个照片集p
p = []
for i in range(M):
    p.append(list(map(eval, input().split())))
A, B = map(eval, input().split())
flag_A=0
flag_B=0
# 判断A，B的正负性(应该没有gay吧.....)
if A > 0:
    judge_A = 1
    judge_B = 0
else:
    judge_A = 0
    judge_B = 1

# 建立A,B的hash字典（为了方便起见（我是直接对着例子进行分析的，所以我命名的规则就是按照给的实例一命名的））
hashmap_A = dict()
hashmap_B = dict()
# 循环遍历照片集p
for i in p:
    # 首先要对i进行排序(从小到大或者从大到小应该没那么严格的要求)，排完序之后再进行二分查找
    # n表示i照片的第一个元素——也就是照片中的人数（pop出来再排序懂得都懂）
    n = i.pop(0)
    sorted(i, reverse = True)

    # 二分查找i中是否有A,B，因为我们最后需要判断的A,B相对应的关系，所以这样可以减少无关数据的判断
    # 用m_A来记录找到的A的下标 用m_B来记录找到的B的下标
    m_A = binary_serch(i, A)
    m_B = binary_serch(i, B)

    # 如果m_A和m_B的值不为none也就是找到了那么就弹出A和B
    if m_A != None:
        i.pop(m_A)
        flag_A=1
    # 否则我们就可以不用查找关于A的异性了（A都没在里面，当然对于A来说这张照片中其他人就是无效数据了）
    if m_B != None:
        i.pop(m_B)
        flag_B=1
    # 然后开始查找i中相应的负数和正数对应的添加到A,B的hash字典中去
    for k in i:
        # 如果A在i里面而且 A是正数的话，那我们就去i中找负数，而且找到的负数添加到A的hash字典中去
        if flag_A and judge_A:
            if k < 0:
                hashmap_A[k] = hashmap_A.get(k, 0) + 1 / n
        if flag_B and judge_B:
            if k < 0:
                hashmap_B[k] = hashmap_A.get(k, 0) + 1 / n
        if flag_A and not judge_A:
            if k > 0:
                hashmap_A[k] = hashmap_B.get(k, 0) + 1 / n
        if flag_B and not judge_B:
            if k > 0:
                hashmap_B[k] = hashmap_B.get(k, 0) + 1 / n
# 然后开始查找两个hashmap中的max
# 首先进行排序
l_hashmap_A = list(hashmap_A.items())
s_l_A = sorted(l_hashmap_A, key=lambda x: x[1], reverse=True)
# 然后返回排序后的第一个值也就是max
max_l_A = s_l_A[0][1]
l_hashmap_B = list(hashmap_B.items())
s_l_B = sorted(l_hashmap_B, key=lambda x: x[1], reverse=True)
max_l_B = s_l_B[0][1]

# 然后到两个字典里面去找max对应的key并分别返回一个最大值列表，
# 如果A,B同时都是二者最大值列表中的值，输出一行就可以了
# 如果并没有那么就分别输出就可以了
maxlistA = []
maxlistB = []
for i in hashmap_A.items():
    if i[1] == max_l_A:
        maxlistA.append(i[0])
    if i[1] == max_l_B:
        kuzi_A = 1
for i in hashmap_B.items():
    if i[1] == max_l_B:
        maxlistB.append(i[0])
    if i[1] == max_l_A:
        kuzi_B = 1
if kuzi_A and kuzi_B:
    print("{} {}".format(A, B))
# 按照绝对值从小到大输出
else:
    maxlistA2 = sorted(maxlistA, key=abs, reverse=True)
    maxlistB2 = sorted(maxlistA, key=abs, reverse=True)
    for i in maxlistA2:
        print("{} {}".format(A, i))
    for i in maxlistB2:
        print("{} {}".format(B, i))

换了种找字典中最大值的方法：还是错。。。。。。

#encoding=utf-8
def binary_serch(nums, target):
    i = 0
    j = len(nums) - 1
    m = -1
    while i <= j:
        m = (i + j) // 2
        if target == nums[m]:
            return m
        elif target > m:
            i = m + 1
        else:
            j = m - 1

#变量的声明
flag_A=False
flag_B=False
# 控制输入
N, M = map(eval, input().split())

# 准备一个照片集p
p = []
for i in range(M):
    p.append(list(map(eval, input().split())))
A, B = map(eval, input().split())
# 判断A，B的正负性(应该没有gay吧.....)
if A > 0:
    judge_A = 1
    judge_B = 0
else:
    judge_A = 0
    judge_B = 1

# 建立A,B的hash字典（为了方便起见（我是直接对着例子进行分析的，所以我命名的规则就是按照给的实例一命名的））
hashmap_A = dict()
hashmap_B = dict()
# 循环遍历照片集p
for i in p:
    # 首先要对i进行排序(从小到大或者从大到小应该没那么严格的要求)，排完序之后再进行二分查找
    # n表示i照片的第一个元素——也就是照片中的人数（pop出来再排序懂得都懂）
    n = i.pop(0)
    sorted(i, reverse = True)

    # 二分查找i中是否有A,B，因为我们最后需要判断的A,B相对应的关系，所以这样可以减少无关数据的判断
    # 用m_A来记录找到的A的下标 用m_B来记录找到的B的下标
    m_A = binary_serch(i, A)
    m_B = binary_serch(i, B)

    # 如果m_A和m_B的值不为none也就是找到了那么就弹出A和B
    if m_A != None:
        i.pop(m_A)
        flag_A=True
    # 否则我们就可以不用查找关于A的异性了（A都没在里面，当然对于A来说这张照片中其他人就是无效数据了）
    if m_B != None:
        i.pop(m_B)
        flag_B=True
    # 然后开始查找i中相应的负数和正数对应的添加到A,B的hash字典中去
    for k in i:
        # 如果A在i里面而且 A是正数的话，那我们就去i中找负数，而且找到的负数添加到A的hash字典中去
        if flag_A and judge_A>0:
            if k < 0:
                hashmap_A[k] = hashmap_A.get(k, 0) + 1/n
        if flag_B and judge_B>0:
            if k < 0:
                hashmap_B[k] = hashmap_A.get(k, 0) + 1/n
        if flag_A and  judge_A<0:
            if k > 0:
                hashmap_A[k] = hashmap_B.get(k, 0) + 1/n
        if flag_B and  judge_B<0:
            if k > 0:
                hashmap_B[k] = hashmap_B.get(k, 0) + 1/n
# 然后开始查找两个hashmap中的max
# 首先进行排序
l_hashmap_A = list(hashmap_A.items())
#s_l_A = sorted(l_hashmap_A, key=lambda x: x[1], reverse=True)
# 然后返回排序后的第一个值也就是max
#max_l_A = s_l_A[0][1]
s_l_A = sorted(zip(hashmap_A.values(),hashmap_A.keys()))
max_l_A=max(s_l_A)[1]
l_hashmap_B = list(hashmap_B.items())
#s_l_B = sorted(l_hashmap_B, key=lambda x: x[1], reverse=True)
#max_l_B = s_l_B[0][1]
s_l_B = sorted(zip(hashmap_B.values(),hashmap_B.keys()))
max_l_B=max(s_l_B)[1]



# 然后到两个字典里面去找max对应的key并分别返回一个最大值列表，
# 如果A,B同时都是二者最大值列表中的值，输出一行就可以了
# 如果并没有那么就分别输出就可以了
maxlistA = []
maxlistB = []
for i in hashmap_A.items():
    if i[1] == max_l_A:
        maxlistA.append(i[0])
for i in hashmap_B.items():
    if i[1] == max_l_B:
        maxlistB.append(i[0])

#然后二分查找两个最亲密关系中是不是有对方
A_beleave=binary_serch(maxlistA,B)
B_beleave=binary_serch(maxlistB,A)
if A_beleave != None and B_beleave != None:
    print("{} {}".format(A, B))
# 按照绝对值从小到大输出
else:
    maxlistA2 = sorted(maxlistA, key=abs, reverse=True)
    maxlistB2 = sorted(maxlistA, key=abs, reverse=True)
    for i in maxlistA2:
        print("{} {}".format(A, i))
    for i in maxlistB2:
        print("{} {}".format(B, i))