需要木刻递归建议

Question

给你一个长度为“n”的木头。日志上有“m”标记。必须在每个标记处切割原木。切割成本等于被切割原木的长度。给定这样的原木，确定切割成本最低。

我的部分解决方案是使用递归： 当我按顺序进入标记阵列时，即从第 0 次切割到阵列切割结束时，我能够获得成本。然而，当我们不按顺序切割时，我被困在如何为序列编写代码，即在随机序列中，例如代码可以解释切割不按顺序的情况，并为所有这些情况取最大值。

一种解决方案是对标记数组进行所有排列。为所有排列调用木刻函数并取最大值，但这似乎是幼稚的方法。

有什么建议吗？

标记 = [2, 4]（切割点）

int woodcut(length, cut_point, index){
    if (cut_point > length)
            return INFINITY
    first_half = cut_point;
    second_half = length - cut_point
    if (markings[index++] == exist) {
            if (next_cut_point > first)
                    cost = length + woodcut(second_half, next_cut_point-first)
            else    
                    cost = length + woodcut(first_half, next_cut_point)  
    } else if (index >= sizeof(markings))
            return cost;
}

http://www.careercup.com/question?id=5188262471663616

在查找答案并在一些慷慨的人的帮助下，我能够编写以下解决方案：

    #include <stdio.h>

    int min(int a, int b)
    {
            return a>b?b:a;
    }

    int min_cut(int first, int last, int size, int *cuts)
    {
            int i;
            unsigned int min_cost = 1U<<30;
            /* there are no cuts */
            if (size == 2)
                    return 0;
            /* there is only one cut between the end points */
            if (size == 3)
                    return last - first;
            /* cut at all the positions and take minimum of all */
            for (i=1;i<size;i++) {
                    if (cuts[i] > first && cuts[i] < last) {
                            int cost = last-first + min_cut(first, cuts[i], i+1, cuts) +
                                                    min_cut(cuts[i], last, size - i, cuts);
                            min_cost = min(cost, min_cost);
                    }
            }
            return min_cost;
    }

    int main()
    {
            int cuts[] = {0, 2, 4, 7, 10};
            int size = sizeof(cuts)/sizeof(cuts[0]);
            printf("%d", min_cut(cuts[0], cuts[size-1], size, cuts));
            return 0;
    }

Answer 1

方法 A：

首先编写一个朴素的递归函数，计算从ith 标记到jth 标记的最便宜的切割成本。通过在所有可能的第一次切割中取第一次切割的成本加上切割两个侧面的最低成本来做到这一点。

记住这个函数，让它更高效。

方法 B： 计算一个值表，用于计算从ith 标记到jth 标记的最便宜的切割成本。使用标记数量i 和j 分开的外循环，然后使用i 的内循环，然后是可能进行第一次切割的非常内循环。

这两种方法都有效。两者都是O(m*m*m) 我通常会采用方法 A。

Answer 2

动态编程。复杂度 O(m^3)。 python中的解决方案。输入为标记位置的有序列表，最后一项为日志长度：

def log_cut(m):
  def _log_cut(a, b):
    if mat[a][b]==None:
      s=0
      min_v=None
      for i in range(a+1, b):
         v=_log_cut(a, i)+_log_cut(i, b)
         if min_v==None or v<min_v:
           min_v=v
      if min_v!=None:
        s=min_v+m[b-1]
        if a>0:
          s-=m[a-1]
      mat[a][b]=s
    return mat[a][b]

  mat=[[None for i in range(len(m)+1)] for j in range(len(m)+1)]
  s=_log_cut(0, len(m))
  return s

Answer 3

这种情况类似于分而治之的排序。以快速排序为例：

• 有一个分区步骤需要对阵列进行线性传递以将其分成两个子阵列。同样，切割原木的成本等于其长度。
• 然后有一个递归步骤，其中每个子数组都被递归排序。同样，您必须递归地继续切割原木被切割成的两块中的每一个，直到切割完所有标记。

当然，快速排序在最佳情况下是 O(n log n)，当每个分区步骤（基本情况除外）将数组分成两个大小几乎相等的子数组时，就会发生这种情况。因此，您需要做的就是找到最靠近中间的标记，“切割”那里的日志，然后递归。