【完美世界笔试】4个算法题，1.礼物盒子 2.友谊的小船 3.背包最大价值 4. 五点间最短路径

笔试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的背包中最大价值。即设置$dp[i][j]$，表示前i件中若干个物品放入体积为j的背包中的最大价值。

（2）初始状态

初始状态为$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数组长为道具数，宽为背包容量，$dp[i][j]$ 的每个数都表示，包中可以装前 $i$ 个物品时，包中最大容量为 $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))