笔试java岗,不过其实很久没看了,真的不熟,
就说说算法部分吧
1.礼物盒子
思路: 要么最大长嵌套,要么最大宽嵌套,两者取最大
100%通过代码:
number=int(input())
boxs=[]
boxs2=[]
for i in range(0,number):
l,w=input().split()
boxs.append((int(l),int(w)))
boxs2.append((int(w),int(l)))
boxs.sort()
boxs2.sort()
can_add=1
box=boxs[0]
for i in range(1,number):
if box[0]<boxs[i][0] and boxs[i][1]>box[1]:
can_add+=1
box=boxs[i]
#print(box,boxs[i])
can_add2=1
box=boxs2[0]
for i in range(1,number):
if box[0]<boxs2[i][0] and boxs2[i][1]>box[1]:
can_add2+=1
box=boxs2[i]
#print(box,boxs[i])
if(can_add2>can_add):
print(can_add2)
else:
print(can_add)
2.友谊的小船
思路:
大的体重匹配尽量大的体重,尽量达到每个船满载
可以通过这样的排序处理得到
100%通过代码:
def find_weight(peo_weight,weight):
i=0
max=0
while(i<len(peo_weight)and peo_weight[i]<=weight):
if(peo_weight[i]>=max):
max=peo_weight[i]
i+=1
else:
break
if max!=0:
peo_weight.remove(max)
return max
weights=input().split()
max_boat=int(input())
peo_weight=[]
for wi in weights:
peo_weight.append(int(wi))
peo_weight.sort(reverse=False)
boat=0
while(len(peo_weight)!=0):
wi=peo_weight[0]
peo_weight.remove(wi)
left_wi=max_boat-wi
max_find=find_weight(peo_weight,left_wi)
#print(wi,max_find)
#print(peo_weight)
boat+=1
print(boat)
3.背包最大价值
思路:
算出各自的单位价值,并排序,但是这样不够,因为还要考虑背包的剩余空间。
通过了87%的代码:
# 贪心算法
n=int(input())
bag=int(input())
weight=input().split()
value=input().split()
things=[]
for i in range(0,n):
things.append((float(value[i])/float(weight[i]),int(value[i]),int(weight[i])))
things.sort(reverse=True)
print(things)
sum=0
val=0
for thing in things:
if(sum+thing[2]<=bag):
val=val+thing[1]
sum=sum+thing[2]
print(val)
这样的问题最大的难点就是如何确定贪心条件,由于这个题是0-1背包问题,所以无最优贪心选择,
参考网址:动态规划与0-1背包问题解析
引申问题:贪心算法总结示例与钞票问题的求解
但是可以用动态规划的方法解决这个问题。
动态规划求解具有以下的性质:最优子结构性质和子问题重叠性质
- 最优子结构性质: 最优解包含了其子问题的最优解,不是合并所有子问题的解,而是找最优的一条解线路,选择部分子最优解来达到最终的最优解。
- 子问题重叠性质: 先计算子问题的解,再由子问题的解去构造问题的解(由于子问题存在重叠,把子问题解记录下来为下一步使用)。
①、将原问题分解为子问题
(子问题和原问题形式相同,且子问题解求出就会被保存);
②、确定状态:
0-1背包中一个状态就是N个物体中第i个是否放入体积为V背包中;
③、确定一些初始状态
(边界状态)的值;
④、确定状态转移方程,
如何从一个或多个已知状态求出另一个未知状态的值。(递推型)
(1)确认子问题和状态
01背包问题需要求解的就是,为了体积V的背包中物体总价值最大化,N件物品中第i件应该放入背包中吗?(其中每个物品最多只能放一件)
为此,我们定义一个二维数组,其中每个元素代表一个状态,即前i个物体中若干个放入体积为j的背包中最大价值。即设置
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j],表示前i件中若干个物品放入体积为j的背包中的最大价值。
(2)初始状态
初始状态为 d p [ 0 ] [ 0 ] d p [ 0 ] [ V ] 和 d p [ 0 ] [ 0 ] d p [ N ] [ 0 ] dp[0][0]~dp[0][V]和dp[0][0]~dp[N][0] dp[0][0] dp[0][V]和dp[0][0] dp[N][0]都为0,前者表示前0个物品(也就是空物品)无论装入多大的包中总价值都为0,后者表示体积为0的背包啥价值的物品都装不进去。
(3)转移函数:
当第i个物品能够放进背包时(即背包容量j大于等于物品i的重量weight[i]),比较放入物品i前后,背包总价值,保留最大价值存放于当前状态。否则,直接不放入物品i。
# 动态规划DP方法求解0-1背包问题
# 贪心算法
n=int(input()) # 道具数量
bag=int(input()) # 背包容量
weight=input().split() # 地面道具重量
value=input().split() # 道具价值
things=[]
things.append((0,0))
for i in range(0,n): # 绑定对应的道具重量和价值
things.append((int(value[i]),int(weight[i])))
print(things)
dp = []
for i in range(0, len(things)):
dp.append([0]*(bag+1))
for i in range(0, len(things)):
for j in range(0, bag+1):
if things[i][1] <= j:
# 第i个物品能够放进背包时(即背包容量j大于等于物品i的重量weight[i])
# 比较放入物品i前后,背包总价值,保留最大价值存放于当前状态
dp[i][j] = max(dp[i-1][j], dp[i-1][j-things[i][1]]+things[i][0])
else:
dp[i][j] = dp[i-1][j]
for k in dp:
print(k)
print(dp[len(things)-1][bag]) # 返回二维数组最后一个值
总结:
这里需要dp数组长为道具数,宽为背包容量,
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j] 的每个数都表示,包中可以装前
i
i
i 个物品时,包中最大容量为
j
j
j 时的最大价值 。
例如:
- 当包中可以放前3个物品,包空间最大为10时,最大价值为32
- 当包中可以放前4个物品,包空间最大为14时,最大价值可以是60
4. 五点间最短路径
ABCDE五个地点,-1表示单向不可达,求解从A 到 BCDE的最短路径:
输入:
0 1 12 -1 -1
-1 0 9 3 -1
-1 -1 0 -1 5
-1 -1 4 0 13
-1 -1 -1 -1 0
输出:
1
8
4
13
参考网址:【Python实现】Dijkstra算法
单源最短路径有多种解,例如Dijkstra,Ford,dag等等,
我就只说下dijkstra吧,网上很多相关的算法,实现也很多,但是感觉都太复杂。
《算法导论》原文
解释:图解参考
初始情况假设如图:
该图邻接矩阵:
0 10 3 -1 -1
-1 0 1 2 -1
-1 4 0 8 2
-1 -1 -1 0 7
-1 -1 -1 9 0
算法选定一个源点,这里选了A,在邻接矩阵里是第一行,
此时已知最小距离是A到C,选择
{
A
.
C
}
\{A.C\}
{A.C}集合作为出发点,再出发找到达A,C的最小距离,由于A到各点距离已经计算过了,现在计算从A出发经过C到各点最小距离。
现在
{
A
,
C
,
E
}
\{A,C,E\}
{A,C,E}是最小距离集合,计算其他点到该集合的距离
{
A
,
C
,
E
,
B
}
\{A,C,E,B\}
{A,C,E,B}是最小距离集合,计算其他点到该集合的距离
计算完毕得到最小集合,
代码:
'''
输入:邻接矩阵,
输出,源点V0到各点的最小距离
'''
def Dijkstra(graph,v0):
n=len(graph)
# final保存那些已经被选定的点,D保存当前已经被选定点的最小路径,
final,D=[0]*n,[0]*n
for i in range(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 not final[w] and D[w]<min: # 还没有被选定而且当前距离最小
k=w
min = D[w]
final[k]=1 # 选定的点被加入到已经被选择的集合
for w in range(0,n):
# 还没有被选定而且距离比原先小
if not final[w] and min + graph[k][w]<D[w]:
D[w]=min + graph[k][w]
print(D)
return D
graph=[]
for i in range(0,5):
distance=input().replace("-1","99999")
x=list(map(int,distance.split()))
graph.append(x)
print("初始情况:")
for m in graph:
print(m)
print(Dijkstra(graph,0))