Question

我被要求递归地解决以下问题，但我仍然不能。

问题：必须打包以下集中的所有项目

int[] items = new int[] {4, 4, 2, 3};

进入以下方框

int[] boxes = new int[] {5, 8};

目前，在算法结束时我有

Item index: 2
Box index: 1
Items: 0, 0, 0, 3, 
Boxes: 1, 2, 
-------------------------------------------------
It is possible to distribute defined set of items in given boxes.

哪个不正确，因为有一个项目3，并且有两个框，剩余容量为1和2.我从“||”的右侧获得最终的正面结果表达

有人可能会指出错误的代码或推荐正确的解决方案吗？谢谢！

我的java代码如下：

public class Boxes
{
    public static void main(String[] args)
    {
        int[] items = new int[] {4, 4, 2, 3};
        int[] boxes = new int[] {5, 8};

        System.out.println( String.format("It is %spossible to distribute defined set of items in given boxes.", IsFit(items, boxes, 0, 0) ? "" : "NOT " ) );

    }

    private static boolean IsFit(int[] items, int[] boxes, int boxIndex, int itemIndex)
    {
        if (boxIndex == boxes.length)
            return false;

        if (itemIndex == items.length)
            return true;

        boolean result = 
                IsFit(items, boxes, boxIndex + 1, itemIndex)
                || 
                IsFit(items, boxes, boxIndex, itemIndex + 1) 
            ;   

        if (result)
        {
            int storedValue = items[itemIndex];

            if (boxes[boxIndex] >= storedValue)
            {
                boxes[boxIndex] -= storedValue;
                items[itemIndex] = 0;

                /*
                System.out.println( String.format("Item index: %d", itemIndex) );
                System.out.println( String.format("Box index: %d", boxIndex) );

                System.out.print("Items: ");
                for (int i : items)
                    System.out.print( String.format("%s, ", i) );
                System.out.println();


                System.out.print("Boxes: ");
                for (int b : boxes)
                    System.out.print( String.format("%s, ", b) );
                System.out.println();
                System.out.println("-------------------------------------------------");
                */

                result = IsFit(items, boxes, boxIndex, itemIndex + 1);

                items[itemIndex] = storedValue;
                boxes[boxIndex] += storedValue;

            }
        }

        return result;

    }
}

Answer 1

您的代码非常难以理解。我建议以下功能：

private static boolean fits(int[] weights, int[] boxes, int i) {
    if (i == weights.length)
        return true;

    for (int j = 0; j < boxes.length; j++) {
        if (weights[i] <= boxes[j]) {
            boxes[j] -= weights[i];
            if (fits(weights, boxes, i+1))
                return true;

            boxes[j] += weights[i];
        }
    }

    return false;
}

哪个应该被称为

fits(items, boxes, 0);

Answer 2

我从“||”的右侧得到的最终结果表达

我相信你错了。你的最终结果可能来自于：

if (itemIndex == items.length)
    return true;

当然这并不能解决整个问题。问题是（我可以看到）Knapsack Problem NP-complete的情况，您必须使用强力算法解决它。

Answer 3

这个挑战有impressed我很多，这就是为什么我发布我的答案虽然这个问题被接受了。！

  private static boolean CheckTheBox(int[] a,int[] b,int i,int j)
     {           
            i+=(a[i]==0)?1:0;
            j+=(b[j]==0)?1:0;

            if(i > a.length -1 || j > b.length -1)
            {
                return (a[a.length-1]==0 && b[b.length-1]==0)?true:false;
            }

            int temp=a[i];
            a[i]-=(a[i]!=0 && b[j]!=0)?1:0;
            b[j]-=(b[j]!=0 && temp!=0)?1:0;

            CheckTheBox(a,b,i,j);

            return (a[a.length-1]==0 && b[b.length-1]==0)?true:false;
    }

可以像下面这样调用，

System.out.println((CheckTheBox(items,boxes,0,0)==true?"Filled Successfully.!":"Items/Boxes Remaining.!"));

使用递归算法打包一组框

3 个答案: