【美团点评2020校招测试方向笔试题】算法题部分1.删除字符 2.队列组合排序 3.寻找最小子字符串 4.最大矩形 5.最短送餐路程计算

最新推荐文章于 2022-03-14 17:07:28 发布

甜甜圈Sweet Donut

最新推荐文章于 2022-03-14 17:07:28 发布

阅读量1.4k

点赞数 1

分类专栏：算法人生感悟 c++ 文章标签：字符串算法 python 数据结构

本文链接：https://blog.csdn.net/qinglingLS/article/details/105472620

版权

算法同时被 3 个专栏收录

46 篇文章 1 订阅

订阅专栏

c++

33 篇文章 0 订阅

订阅专栏

人生感悟

24 篇文章 1 订阅

订阅专栏

做题网址：点击进入

1.[编程题]删除字符

将给定的字符串，按照规则删除字符，输出删除后的字符串。删除规则为：相同字符连续，则删除，如”aaaab”删除后的字符串为”b” 。注：仅是单个字符连续才删除，如babababa则不能删除；
输入描述:
输入数据有多组，每组一行，仅包含数字和英文字母，不包含转义等其他特殊字符，输入数据最大长度为10；
输出描述:
对于每个测试实例，要求输出按规则删除后的数据，每个测试实例的输出占一行。如果删除后有字符，直接输出删除后的字符；如果删除后为空，则输出”no”
示例1
输入

a
aaaaabbbb

输出

a
no

思路： 双指针保存目前状态和下一个状态。
通过代码：
在这里插入图片描述

import sys
while True:
    line=sys.stdin.readline()
    if not line:
        break
    cp_char=''
    output=''
    for i in range(0,len(line)-1):
        cur_char=line[i]
        if line[i+1]==cur_char:
            cp_char=cur_char
            continue
        if line[i]==cp_char:
            continue
        else:
            output+=line[i]
    if(len(output)==0):
        print('no')
    else:
        print(output)

2.[编程题]队列组合排序

做题网址：
一个班级男生和女生数量相同，老师要求男生女生进行排队，男生全部排在队列前面，女生紧跟着排在男生队列后面，形成一个队列，现在要求男生女生交叉排列并且第一位是男生，且每个人在在原队列中的顺序不变，如何来做？

要求：
交叉前：队列[男1，男2，男3，男4…男n，女1，女2，女3，女4…女n]
交叉后：队列[男1，女1，男2，女2，男3，女3，男4，女4…男n，女n]

输入描述:
输入第一行一个整数 n 表示有 n 个男生和 n 个女生
第 2 到第 n+1 行每一行有一个数字表示每个男生的编号
第 n+2 到第 2*n+1 行每一行有一个数字表示每个女生的编号

输出描述:
输出 2*n 行，每行一个名字表示交叉排列后队列中依次每个学生的编号
示例1
输入

输出

说明
男【1,2,3】+女【4,5,6】。交叉后变为：【1,4,2,5,3,6】

备注:
$1<=n<=10^5$ ，
每个学生的标号互不相同，并且标号 x 满足：
$1<=x<=10^9$

思路：
就分别存然后打印就好了

n=int(input())
boy=[]
girl=[]
for i in range(0,n):
    boy.append(int(input()))
for i in range(0,n):
    girl.append(int(input()))
line=[]
for i in range(0,n):
    line.append(boy[i])
    line.append(girl[i])
for i in range(0,2*n):
    print(line[i])

3.[编程题]寻找最小子字符串

挑战网址：立即点击挑战
小美和小团在玩一个游戏，小美任意给出一个大字符串str1以及一个独立的小字符串str2，小团需要从这个大字符串str1里找到包含独立小字符串str2中所有字符的最小子字符串str3；
例如，小美给出一个大字符串"meituan2019"和一个子字符串"i2t"，那么小团给出的答案就应该是"ituan2"；
需要注意：
1、str1中有可能没有完整包含str2所有字符的情况，此时返回""，即为空字符串；
2、str1不会为空，但str2有可能为空，此时返回整个str1；
3、str2可能存在重复的字符，此时str3需要包含相等数量该字符；

示例1
输入

"meituan2019","i2t"

输出

"ituan2"

备注:

str1，str2 的长度均不超过100

思路：
双指针，遇到子串元素就存储，并且把子串里的该元素删除，否则就跳过，直到子串被查完

错误却100%通过了的代码：

# 寻找最小子串
str1,str2=input().split('","')
str1=str1.replace("\"","")
str2=str2.replace("\"","")
save=[]
i=0
j=0
flag=False
while(i<len(str1) and j<len(str2)):
    if(str1[i] in str2): # 遇到子串元素
        save.append(str1[i])
        flag=True
        j+=1
    elif flag:
        save.append(str1[i])
    i+=1

if len(str2)==0:
    print(str1)
elif j!=len(str2):
    print("")
else:
    string='"'
    for ch in save:
        string=string+ch
    print(string+"\"")

当输入为："meit2uan2019tt","i2tt"时，得到错误解
在这里插入图片描述
说明写美团题目的测试开发工程师很不到位啊(doge)
正确的解：

# 寻找最小子串
str1,str2=input().split('","')
str1=str1.replace("\"","")
str2=str2.replace("\"","")
str_set=[]
for i in range(0,len(str2)):
    str_set.append(str2[i])
save=[]
i=0
j=0
flag=False
while(i<len(str1) and j<len(str2)):
    if(str1[i] in str_set): # 遇到子串元素
        save.append(str1[i])
        str_set.remove(str1[i]) # 待查找集合中 删掉该元素
        flag=True
        j+=1
    elif flag:
        save.append(str1[i])
    i+=1
if len(str2)==0:
    print("\""+str1+"\"")
elif j!=len(str2):
    print("\"\"")
else:
    string='"'
    for ch in save:
        string=string+ch
    print(string+"\"")

4.[编程题]最大矩形

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
输入描述:
输入一个仅包含’0’和’1’的二维字符数组。
第一行输入左大括号{，最后一行输入右大扩号}。
中间每行输入只包含’0’和’1’的字符数组（字符数组的长度不超过20），字符使用单引号’’，字符之间使用逗号,隔开，字符数组的开始和结束使用大括号{}。
字符数组之间换行，并使用逗号，隔开。（字符数组的个数不超过20）。
输出描述:
输出只包含字符’1’的最大矩形的面积。

示例1
输入

{
{'1','0'},
{'1','0'}
}

输出

示例2
输入

{
{'0','0'},
{'0','1'}
}

输出

参考网址：
[1]Leecode最大矩形思路
[2]详细通俗的思路分析，多解法

美团这个题把 {} 改为 [ 和 ] ,用python 的eval()转为列表，后面的做法和最大矩形一样。

1.暴力破解：

遍历每一行，求解高度为1的矩形 连续1 的个数，并且更新数组中的该值。
向上扩展一行，高度增加一，选出 当前列最小的数字 (图中四所在列最小是2，面积2*2)，作为矩阵的宽，求出面积，对应上图的矩形框。（可知列最小的数字决定了左边界）
然后继续向上扩展，重复步骤 2。算出所有高度（1，2，3，4）的情况。
遍历所有的点，求出所有的矩阵就可以了。

不过由于复杂度太高，会导致超时：

class Solution:
    def maximalRectangle(self, matrix) -> int:
        inp=matrix
        save=[[0 for i in range(len(inp[0]))]for i in range(len(inp))]
        # 计算高度为1时的宽度矩阵
        for j in range(0,len(inp)):
            width=0
            for k in range(0,len(inp[0])):
                if int(inp[j][k])==1:
                    width+=1
                    save[j][k]=width
                else:
                    width=0
        # print(save)
        max=0
        if len(save)!=0 and len(save[0])!=0:
            max=save[0][0]
        for i in range(1,len(inp)+1): # i表示高度
            # 计算高度为i时的宽度
            for j in range(0,len(inp)-i+1):# 高度为i，列方向移动len(inp)-i+1次
                width=0
                for k in range(0,len(inp[0])): 
                    # 选出当前列最小的数字
                    min = save[j][k]
                    for p in range(j,j+i): # 固定行，遍历列选出最小
                        if min>save[p][k]:
                            min=save[p][k]
                    tmp=min*i # 当前列最小的数字作为矩阵的宽，高度是i，求出面积
                    if(tmp>max):
                        max=tmp   
        print(max)
        return max
s= Solution()
inp=[["1"]]
s.maximalRectangle(inp)

长为 $m$ ，宽(高)为 $n$
时间复杂度： $O(m*n+n*n*m)=O(m*n^2)$
空间复杂度： $O (m * n)$

2.利用单调栈：

[1]利用类似题目，之前写的博文——求一个直方图矩形的最大面积。
其实也就是求高度（1，2，3，4）不同情况下的最大直方图矩形面积。若底为0，就在直方图里标1，否则标0。
在这里插入图片描述
代码：

class Solution:
    def calcu_max_rec(self,heights):
        stack=[] # 这里把0设置为heights的边界，压栈弹栈时使得边界条件不为空
        heights=[0]+heights+[0] 
        res=0
        for i in range(0,len(heights)):
            while stack and heights[stack[-1]]>heights[i]: # 出现了递减，重复弹栈
                tmp = stack.pop()
                res = max(res,(i-stack[-1]-1)*heights[tmp]) # 弹出后，栈顶为左边界，i是右边界，高度是弹栈的矩形高度
            stack.append(i)
        return res

    def maximalRectangle(self, matrix) -> int:
        if len(matrix)==0 or len(matrix[0])==0:
            return 0
        heights=[0]*len(matrix[0])
        max_size=0
        for i in range(0,len(matrix)):
            for j in range(0,len(matrix[0])):
                # print(matrix[i][j])
                if int(matrix[i][j])>=1:
                    heights[j]+=1
                else:
                    heights[j]=0
            # print(heights)

            tmp=self.calcu_max_rec(heights)
            if max_size<tmp:
                max_size=tmp
        return max_size
s=Solution()
matrix=[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
print(s.maximalRectangle(matrix))

长为 $m$ ，宽(高)为 $n$
时间复杂度 $O (m * n)$
空间复杂度 $O (m)$

3.动态规划方法：

参考网址：[1]动态规划 - 每个点的最大高度
直觉
想象一个算法，对于每个点我们会通过以下步骤计算一个矩形：

不断向上方遍历，直到遇到“0”，以此找到矩形的最大高度。
向左右两边扩展，直到无法容纳矩形最大高度。

给定一个最大矩形，其高为 h，左边界 l，右边界 r，在矩形的底边，区间 [l, r] 内必然存在一点，其上连续1的个数（高度）<=h。若该点存在，则由于边界内的高度必能容纳 h，以上述方法定义的矩形会向上延伸到高度 h，再左右扩展到边界 [l, r] ，于是该矩形就是最大矩形。
若不存在这样的点，则由于[l, r]内所有的高度均大于 h，可以通过延伸高度来生成更大的矩形，因此该矩形不可能最大。

综上，对于每个点，只需要计算h， l，和 r - 矩形的高，左边界和右边界。
使用动态规划，我们可以在线性时间内用上一行每个点的 h，l，和 r 计算出下一行每个点的的h，l，和r。

算法：
总而言之，要找尽可能大的高度，尽可能左的左边界，尽可能右的右边界。

代码：
在这里插入图片描述

# 动态规划方法：
class Solution:
    def maximalRectangle(self, matrix) -> int:
        if not matrix:return 0
        height=len(matrix)
        width=len(matrix[0])
        heights=[0]*width
        left=[0]*width # 初始化左边界为最左边界
        right=[width]*width # 初始化右边界为最右边界
        
        maxarea=0
        for i in range(height):
            cur_left,cur_right=0,width
            # 更新当前行的高度
            for j in range(width):
                if matrix[i][j]=='1':heights[j]+=1
                else: heights[j]=0
            # 更新左边界
            for j in range(width):
                if matrix[i][j]=='1':left[j]=max(left[j],cur_left)
                else:
                    left[j]=0
                    cur_left=j+1  
                    # 是我们遇到的最右边的0的序号加1。当将矩形向左 “扩展” ，
                    # 不能超过该点，否则会遇到0。
            # 更新右边界
            for j in range(width-1,-1,-1):
                if matrix[i][j]=='1':right[j]=min(right[j],cur_right)
                else:
                    right[j]=width
                    cur_right=j
            # 更新最大边界
            for j in range(width):
                maxarea=max(maxarea,heights[j]*(right[j]-left[j]))
        return maxarea
                

s=Solution()
matrix=[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
print(s.maximalRectangle(matrix))

5.[编程题]最短送餐路程计算

美团外卖是知名的外卖平台，现在有一名新入职的外卖小哥。请你给他写一段程序根据外卖地图和交通拥堵情况，告诉他从“配送点”V0，到各个目的地的最短配送距离。其中拥堵程度可以与路径参数直接相加，例如：V0点拥堵，拥堵系数是2，那么在地图上V0点的3条线路的参数都要加2，由原来的1、2、7变为3、4、9再进行。
在这里插入图片描述路径规划计算。路径参数越大代表路程越长。
输入描述:
输入数据只有一行，有三个int型参数，分别表示：目的地编号、拥堵节点编号和拥堵值。
例如： 4 3 1，代表目的地是V4，在V3节点有拥堵情况，拥堵系数是1。
输出描述:
输出一个数字表示有起点V0到终点的最短距离
示例1
输入

4 2 1

输出

示例2
输入

5 4 1

输出

做题地址:最短送餐路程计算

思路：
最短路径算法+邻接矩阵
详细参考之前写的博文，第四题最短路径问题

代码：

# dijksta算法
class Solution:
    '''
    输入：邻接矩阵，
    输出，源点V0到各点的最小距离
    '''
    def Dijkstr(self,graph,v0):
        # final 保存已经遍历过的点，d保存最短路径
        n=len(graph)
        final,D=[0]*n,[0]*n
        for i in range(0,n):
            D[i]=graph[v0][i]
        D[v0]=0
        final[v0]=1
        for v in range(1,n):
            min = float("Inf")
            for w in range(0,n):
                if final[w]==0 and D[w]<min:
                    k=w
                    min=D[w]
            final[k]=1
            for w in range(0,n):
                if final[w]==0 and min +graph[k][w]<D[w]:
                    D[w]=min +graph[k][w]
        return D

s = Solution()
aim,crowd,exp=map(int,input().split())

graph=[
[0,1,2,7,9999,9999],
[1,0,2,9999,5,4],
[2,2,0,4,4,9999],
[7,9999,4,0,6,9999],
[9999,5,4,6,0,3],
[9999,4,9999,9999,3,0]
]
for i in range(0,len(graph)):
    for j in range(0,len(graph)):
        if i==crowd or j==crowd:
            graph[i][j]+=exp
print(s.Dijkstr(graph,0)[aim])

甜甜圈Sweet Donut

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
【美团点评2020校招测试方向笔试题】算法题部分1.删除字符 2.队列组合排序 3.寻找最小子字符串 4.最大矩形 5.最短送餐路程计算

做题网址：点击进入[编程题]删除字符将给定的字符串，按照规则删除字符，输出删除后的字符串。删除规则为：相同字符连续，则删除，如”aaaab”删除后的字符串为”b” 。注：仅是单个字符连续才删除，如babababa则不能删除；输入描述:输入数据有多组，每组一行，仅包含数字和英文字母，不包含转义等其他特殊字符，输入数据最大长度为10；输出描述:对于每个测试实例，要求输出按规则删除后的数据，...
复制链接

扫一扫