2020华为秋招笔试（2）

2020
编程1：题目描述
一个直角三角形的周长是120的话，那么它的三边可以是20，48，52，或者24，45，51，还有30，40，50，有3种不同的解。现在你想知道如果给定一个直角三角形的周长，那么这个周长最多能有多少解呢？假设边长为整数。

输入
第一行一个T TT,表示T TT组测试数据。1≤T≤10000 1\leq T\leq 100001≤T≤10000
每组测试数据占一行仅含一个整数A AA。0≤A≤100000 0\leq A\leq 1000000≤A≤100000

输出
根据每组测试数据请求出以整数A为周长的直角三角形的个数。（边长都为整数的直角三角形且周长为整数A）

https://blog.csdn.net/gooding300/article/details/86555475

#法一：
# p = int(input())
# q = int(p/3)
# n=0
# li=[]
# for x in range(1,q+1):
#     y = p*(p-2*x)/(2*(p-x))
#     z=p-x-y
#     lengths=sorted([x,y,z])
#     if (y-int(y)==0) and (z-int(z)==0 and lengths not in li):
#         n=n+1
#         li.append(lengths)
# print(n)



#法一：枚举法，枚举三条边，最终可能时间超时。（三重循环）
# ans = 0
# p = int(input())
# for i in range(1,p):
#     i+=1
#     for j in range(1,p):
#         j+=1
#         for k in range(1,p):
#             k+=1
#             if i+k+j == p and i*i +j*j == k*k:
#                 ans+=1
# print(ans/2)

#法二：二重循环,可以通过
# 首先，我们先对问题进行数学分析：
# 已知 i+j+k=l i+j+k=li+j+k=l ， 0&lt;i≤j&lt;k 0&lt;i\leq j&lt;k0<i≤j<k ，
# 通过不等式可以得到 i&lt;l/3 i&lt;l/3i<l/3 ， j&lt;l/2 j&lt;l/2j<l/2 。
# 在二重循环的基础上，对i ii和j jj的范围进行限制

# ans =0
# p = int(input())
#
# for i in range(1,p//3):
#     i+=1
#     for j in range(i,p//2):
#         j+=1
#         k= p-i-j
#         if i*i+j*j == k*k:
#             ans+=1
# print(ans)

#优化
#再抓住两边之和大于第三边的性质

# ans =0
# p = int(input())
# for i in range(1,p//3):
#     i+=1
#     for j in range(i,p//2):
#         j+=1
#         k = p-i-j
#         if k < i+j and i*i+j*j == k*k:
#             ans+=1
# print(ans)

编程2：
寻找输入数组是否满足矩阵的连通块。

import sys
#宽度优先搜索
def find(mat,i,j,sub,visited=None):
    if visited is None:
        visited = []
    res = 0
    # print([i,j])
    if len(sub)==0:
        return 1    #返回true
    if mat[i][j] in sub and [i,j] not in visited:
        visited.append([i,j])
        print("visited____2:",visited)
        print(sub)
        sub.pop(sub.index(mat[i][j]))
        res = find(mat,max(i-1,0),j,sub,visited) \
              | find(mat,i,max(j-1,0),sub,visited) \
              | find(mat,min(i+1,4),j,sub,visited) \
              | find(mat,i,min(j+1,4),sub,visited)
    elif [i,j] not in visited:
        visited.append([i,j])
        print("visited; ",visited)
    return res

if __name__ =="__main__":
   mat = [
            [1,2,3,4,5],
            [11,12,13,14,15],
            [21,22,23,24,25],
            [31,32,33,34,35],
            [41,42,43,44,45]
        ]
   for line in sys.stdin:
       sub = list(map(int,line.strip().split()))
       res = 0
       for i in range(5):
           for j in range(5):
               res = find(mat,i,j,sub[:])
               if res:
                   break
           if res:
               break

       print(res)';

编程3：

两个整数数组，数字相同顺序不同，求a数组需要删除的最少元素，使两个数组剩下的子数组完全相同。

def subsequence(n,input_x,input_y):
    dp = [([0]*(n+1)) for i in range(n+1)]
    # print(dp)
    for i in range(1,n+1):
        for j in range(1,n+1):
            if i==0 or j==0:
                dp[i][j] = 1
            elif input_x[i-1] == input_y[j-1]:
                dp[i][j] = dp[i-1][j-1]+1
            else:
                dp[i][j] = max(dp[i-1][j],dp[i][j-1])
    return dp[-1][-1]

n = int(input())
alist = list(map(int,input().split()))
blist = list(map(int,input().split()))
print(n-subsequence(n,alist,blist))



#######################

##法一：基于递归的方法
# def recursive_lcs(str_a,str_b):
#     if len(str_a)==0 or len(str_b)==0:
#         return 0
#
#     if str_a[0]==str_b[0]:
#         return recursive_lcs(str_a[1:],str_b[1:])+1
#     else:
#         return max([recursive_lcs(str_a[1:],str_b),recursive_lcs(str_a,str_b[1:])])
#
# n = 4
#str_a = [1,3,5,2]
# str_b= [3,2,1,5]
# print(n-recursive_lcs(str_a, str_b))


##法二：基于自顶向下动态规划的方法
#
# def bottom_up_dp_lcs(str_a,str_b):
#     if len(str_a)==0 or len(str_b)==0:
#         return 0
#
#     dp = [[0 for _ in range(len(str_b)+1)] for _ in range(len(str_a)+1)]
#     # print(dp)
#     for i in range(1,len(str_a)+1):
#         for j in range(1,len(str_b)+1):
#             if str_a[i-1]==str_b[j-1]:
#                 dp[i][j]=dp[i-1][j-1]+1
#             else:
#                 dp[i][j]=max(dp[i-1][j],dp[i][j-1])
#     # return dp[len(str_a)][len(str_b)]
#     print("length of LCS IS :", dp[len(str_a)][len(str_b)])
#
#     #输出最长公共子序列
#     i,j=len(str_a),len(str_b)
#
#     while i>0 and j>0:
#         if str_a[i-1]==str_b[j-1] and dp[i][j]==dp[i-1][j-1]+1:
#             print(str_a[i-1])
#             i,j = i-1,j-1
#             continue
#         if dp[i][j]==dp[i-1][j]:
#             i,j=i-1,j
#             continue
#         if dp[i][j]==dp[i][j-1]:
#             i,j=i,j-1
#             continue
#
#
# str_a = [1,3,5,2]
# str_b= [3,2,1,5]
# bottom_up_dp_lcs(str_a,str_b)

##法三：降低空间复杂度的动态规划算法
#用一维数组代替二维数组,dp矩阵只和三个元素有关：左边的元素，上边的元素，左上角的元素。
def space_efficient_lcs(str_a,str_b):
    if len(str_a)==0 or len(str_b)==0:
        return 0
    dp=[0 for _ in range(len(str_b)+1)]
    for i in range(1,len(str_a)+1):
        left_up=0
        dp[0]=0
        for j in range(1,len(str_b)+1):
            left=dp[j-1]
            up=dp[j]
            if str_a[i-1] ==str_b[j-1]:
                dp[j] = left_up+1
            else:
                dp[j]=max([left,up])
            left_up=up
    print(dp[len(str_b)])



str_a = [1,3,5,2]
str_b= [3,2,1,5]
space_efficient_lcs(str_a,str_b)

https://www.cnblogs.com/CheeseZH/p/8830482.html