Question

我在一场比赛中遇到了这个问题，比赛已经结束。我们有三种类型的硬币A，B和C，它们与它们有关联的价值，并且商店数量为N。我们必须从这些商店中收集N个类型为A，B，C的硬币，这样我们才能选择A类型的X硬币，B类型的Y硬币和C类型的z硬币。另外，我们只能从商店中挑选1个硬币。

我们需要以最大的获利方式收集硬币。

示例：

第一行代表商店数量

第二行代表X，Y，Z。每种类型（A，B，C）分别要挑选的硬币数量

下一行代表该商店中存在的A，B，C硬币的值

4

2 1 1

5 3 4

8 6 1

10 3 3

5 1 5

所以输出-> 26（第一个5到第二个6 +第三个10第四个5）

2个A（5 + 10）型硬币

1个B（6）型硬币

1个类型为C（5）的硬币

我们如何解决这个问题。这是一个动态编程问题吗？

我曾经考虑过应用回溯，但这会花费大量的时间和空间。

Answer 1

我有一个动态编程解决方案，它是O（X * Y * Z * | stores |）。在我的代码中，我假设X + Y + Z = N，但是可以很容易地更改它以解决X + Y + Z <= N的更一般的情况。

该解决方案能够为此特定实例找到正确的答案。我希望比赛真的结束了，这不能解决正在进行的比赛中的问题。

值得一提的是，这段代码找到了OPTIMAL解决方案。通过一些启发式方法，您也许可以提高效率，但是您将不得不放弃寻找最佳解决方案的方法。

#include <vector>
#include <algorithm>
#include <utility>
#include <iostream>
#include <array>
using namespace std;


long long solver(const int X, const int Y, const int Z, const vector< array<long long, 3> >& stores ) 
{
    const int total_stores = (int) stores.size();
    long long DP[X + 1][Y + 1][Z + 1][total_stores + 1];

    // we will consider the stores indexed from [1, ..., total_stores ]

    // DP[v1][v2][v3][i] -> Best way of selecting v1 coins of type A,
    // v2 coins of type B
    // v3 coins of type C
    // and we can consider only the stores from [1, ..., i]

    // Initializing DP
    for(int x = 0; x <= X; ++x) 
    {
        for(int y = 0; y <= Y; ++y) 
        {
            for(int z = 0; z <= Z; ++z) 
            {
                for(int i = 0; i <= total_stores; ++i) 
                {
                    DP[x][y][z][i] = 0;
                }
            }
        }
    }

    // Computing the actual values
    for(int x = 0; x <= X; ++x)
    {
        for(int y = 0; y <= Y && x + y <= total_stores; ++y) 
        {
            for(int z = 0; z <= Z && x + y + z <= total_stores; ++z) 
            {
                for(int i = x + y + z; i <= total_stores; ++i) 
                {
                    if( i == 0) continue;
                    // the values from vector are indexed from 0, but 
                    // here we will index them from 1, so watch out!
                    DP[x][y][z][i] = DP[x][y][z][i - 1]; // We have the option of not using any coins from this specific store

                    if( x > 0) DP[x][y][z][i] = max( DP[x][y][z][i], 
                                          DP[x - 1][y][z][i - 1] + stores[i - 1][0]); // We can use the coin A from this store

                    if( y > 0) DP[x][y][z][i] = max( DP[x][y][z][i],
                                          DP[x][y - 1][x][i - 1] + stores[i - 1][1]); // We can use the coin B from this store

                    if( z > 0) DP[x][y][z][i] = max( DP[x][y][z][i],
                                          DP[x][y][z - 1][i - 1] + stores[i - 1][2]); // We can use the coin C from this store

                }
            }
        }
    }

    return DP[X][Y][Z][total_stores];

}

int main()
{
    vector< array<long long, 3> > stores;
    stores.emplace_back(array<long long, 3>{5, 3, 4} );
    stores.emplace_back(array<long long, 3>{8, 6, 1} );
    stores.emplace_back(array<long long, 3>{10, 3, 3} );
    stores.emplace_back(array<long long, 3>{5, 1, 5} );
    const int X = 2;
    const int Y = 1;
    const int Z = 1;

    cout << "value of the solution is = " << solver( X, Y, Z, stores ) << endl;

    return 0;
}

可以通过动态编程方法或回溯来解决问题

1 个答案: