动态规划-分蛋糕V1

分蛋糕:
有一块矩形大蛋糕，长和宽分别是整数w?、h。现要将其切成m块小蛋糕，
每个小蛋糕都必须是矩形、且长和宽均为整数。切蛋糕时，每次切一块蛋糕，
将其分成两个矩形蛋糕。请计算：最后得到的m块小蛋糕中，最大的那块蛋糕的面积下限。
假设w= 4,?h= 4,?m= 4，则下面的切法可使得其中最大蛋糕块的面积最小。
假设w= 4,?h= 4,?m= 3，则下面的切法会使得其中最大蛋糕块的面积最小:
Input
共有多行，每行表示一个测试案例。每行是三个用空格分开的整数w, h, m ，
其中1 ≤ w, h, m ≤ 20 ， m ≤ wh. 当 w = h = m = 0 时不需要处理，
表示输入结束。
Output
每个测试案例的结果占一行，输出一个整数，表示最大蛋糕块的面积下限。
Sample Input
4 4 4
4 4 3
0 0 0
Sample Output
4
6

实现：递归原理实现:设 DFS(w,h,m)表示宽为w,高为h的蛋糕，被切m刀后，
最大的那块蛋糕的面积最小值，要M块蛋糕，只需要切M-1刀
题目就是要求 DFS(W,H,M-1)
边界条件：1.w * h < m + 1 INF  2.m == 0 w*h
SV为第一刀竖着切时能得到的最好结果，SH为第一刀横着切时能得到的最好结果，
DFS(w,h,m) = min(SV,SH)
SV=min{ Si,i=1...w-1},其中:Si=为第一刀左边宽为i的情况下的最好结果
Si  = min{max(ways(i,h,k),ways(w-i,h,m-1-k)),k=0... m-1}

python算法实现：

# 4 4 3
# [
# [[-1, -1, -1], [-1, -1, -1], [-1, -1, -1], [-1, -1, -1], [-1, -1, -1]],
# [[-1, -1, -1], [1, -1, -1], [2, -1, -1], [3, -1, -1], [4, 2, -1]],
# [[-1, -1, -1], [2, -1, -1], [4, -1, -1], [6, -1, -1], [8, 4, -1]],
# [[-1, -1, -1], [3, -1, -1], [6, -1, -1], [9, -1, -1], [12, 6, -1]],
# [[-1, -1, -1], [4, 2, -1], [8, 4, -1], [12, 6, -1], [-1, -1, 6]]
# ]
# DFS(4,4,2) = max(DFS(3,4,1),DFS(1,4,0))
# 6 =  max(6,4)

# minBigestArea三维列表，0：宽，1：高，2：共切几刀，在w,h的长方形切m刀最大蛋糕的面积最小值
minBiggestArea = []
INF = float("inf")


# 竖着切
def SV(w, h, k):
    sv = INF
    # 第一刀竖着切，因为是整数，刀的位置在1——w之间，遍历第一刀切的位置
    for i in range(1, w):
        # 第一刀切下去了，那么就会产生左右两块蛋糕，剩下切的刀数就是0——k-1，所以遍历循环的范围是k
        # 第一刀切下去后，产生2块蛋糕，那么对左边的蛋糕可能切几刀，取值从0——k-1
        # 知道左边切下去的刀数了，那么就可以计算出还剩余的刀数就给右边来切
        # 以4 4 3为例，如果第一刀切的位置为3，那么就会产生2块蛋糕，左边w=3,h=4 ，右边w=1,h=4
        # 竖切的情况：
        # DFS(4,4,2) = max(DFS(3,4,0),DFS(1,4,1))或者max(DFS(3,4,1),DFS(1,4,0))
        # 因为我们需要找最大那块蛋糕的值，因此要取左右2块蛋糕的max值
        # 那么不同的切法，最大那块蛋糕的值有许多种，题目要求最小的，所以最后就有个min
        for kk in range(0, k):
            # 求1切下去后左边蛋糕在i，h，kk的情况下最大蛋糕的最小值
            leftValue = DFS(i, h, kk)
            # 求1切下去后右边边蛋糕在w-i，h，k-1-kk的情况下最大蛋糕的最小值
            rightValue = DFS(w-i, h, k-1-kk)
            # 左右蛋糕最大蛋糕的最小值求出了，合起来比较，那么sv在w、h、k下最大蛋糕的最小值即可算出
            sv = min(sv, max(leftValue, rightValue))
    return sv


# 横着切与竖的原理是一样的，唯一区别这里是w不变，h变了
def SH(w, h, k):
    sh = INF
    for i in range(1, h):
        for kk in range(0, k):
            leftValue = DFS(w, i, kk)
            rightValue = DFS(w, h-i, k-1-kk)
            sh = min(sh, max(leftValue, rightValue))
    return sh


# w-宽度 h-高度 k-共切几刀
def DFS(w, h, k):
    global minBiggestArea
    # 如果该位置的最大蛋糕最小值已经计算好了，不需要重复计算，直接读出
    if minBiggestArea[w][h][k] != -1:
        return minBiggestArea[w][h][k]
    # w=4，h=4，因为要求蛋糕的边是整数，因此最多可以产生16块小蛋糕，也就是最多可以切15刀
    # 如果切16刀，蛋糕分不出17块，完成不了，因此返回无穷大
    if w * h < k + 1:
        minBiggestArea[w][h][k] = INF
        return minBiggestArea[w][h][k]
    # 如果一刀都不切，那么w*h就是最大蛋糕的最小值
    if k == 0:
        minBiggestArea[w][h][k] = w * h
        return minBiggestArea[w][h][k]
    # 因为蛋糕第一刀切下去，有竖、横两个方向，所以要分别求
    # 第一刀竖着切最大蛋糕的最小值，横着切所得最大蛋糕的最小值
    # 然后再对这2个取最小值，即得该大小蛋糕，共切几刀的最大蛋糕最小值
    minBiggestArea[w][h][k] = min(SV(w, h, k), SH(w, h, k))
    return minBiggestArea[w][h][k]


def main():
    global minBiggestArea
    while True:
        w, h, m = map(int, input().split())
        if w == 0 and h == 0 and m == 0:
            break
        # 构建1个三维列表，因为列表的序号从0开始计算，为了计算方便w、h多增加1，
        # 列表中w、h位置0的值没有意义，不存储数据，仅为计算方便
        # 三维列表从1开始存储，初始化为-1，如果计算过，就存储值下来，避免重复计算，提高效率
        # m这个位置存储的是刀数，要分成m块，需要m-1刀，比如m=3，只需要2刀，所以只需要生成0、1、2
        # 因此m的位置不需要增加1
        minBiggestArea = [[[-1 for i in range(m)] for i in range(h+1)] for i in range(w+1)]
        # print(minBigestArea)
        # w-宽度、h-高度，函数的第3个参数表示总共刀数，切m-1刀，即可得到m块蛋糕
        optimalValue = DFS(w, h, m-1)
        print("最大蛋糕块的面积下限为：%d" % optimalValue)

    return 0


if __name__ == '__main__':
    main()