在特定成本内找到路径

Question

有许多算法或策略可以找到具有最低或最高成本的路径。但是，很难找到一种方法可以找到在（或低于）所需成本 (RC) 的路径，即这样的 RC 不是最小或最大的，而是实际成本应该小于这样的 RC。

我正在寻找一种可行的算法来找到满足这两个约束的路径：

1. 此类路径的成本应低于所需成本。
2. 从源到目的地的路径应包含尽可能多的跃点。

一个例子如下所示， 例如，

源是节点A，目的是节点B；所需成本为 10。从 A 到 B 可以找到 3 条路径：

 1. A --> C --> B;               cost is 5
 2. A --> C --> D --> B;         cost is 8
 3. A --> C --> D --> E --> B;   cost is 12

根据提到的两个约束条件，path 2 (A --> C --> D --> B; cost is 8) 是最好的一个，因为成本为 8，比所需的成本 10 小，并且路径 2 比路径 1 长。

希望我能清楚地解释我的问题。 有没有发布的算法或方法来解决这个问题？

提前谢谢你。

Answer 1

我认为这个问题没有众所周知的算法。

让我给你看看我的sn-p。

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;

class info
{
    public:
        int hopcount;
    vector<int> path;
    int cost;
};

int main()
{
    int n;
    int s, e;
    vector<vector < int>> arr;
    cin >> n;
    arr.resize(n + 1);
    for (int i = 1; i <= n; i++)
    {
        arr[i].resize(n + 1);
    }
    cin >> s >> e;
    int pc;
    cin >> pc;
    for (int i = 0; i < pc; i++)
    {
        int source, def, cost;
        cin >> source >> def >> cost;
        arr[source][def] = cost;
    }
    int maxcost;
    cin >> maxcost;
    queue<info> q;
    q.push({1, {s}, 0 });
    int maxhopcount = -1;
    vector<int> hoppath;
    while (!q.empty())
    {
        auto qel = q.front();
        q.pop();
        int currentN = qel.path[qel.path.size() - 1];
        if (currentN == e)
        {
            if (qel.hopcount > maxhopcount)
            {
                maxhopcount = qel.hopcount;
                hoppath = qel.path;
            }
        }
        for (int i = 1; i <= n; i++)
        {
            int sign = 0;
            for (auto c: qel.path)
            {
                if (c == i)
                {
                    sign = 1;
                    break;
                }
            }
            if (sign == 1) continue;
            if (arr[currentN][i] > 0)
            {
                info ni = qel;
                ni.path.push_back(i);
                ni.hopcount += 1;
                ni.cost += arr[currentN][i];
                if (ni.cost <= maxcost)
                {
                    q.push(ni);
                }
            }
        }
    }
    cout << maxhopcount << endl;
    for (auto c: hoppath)
    {
        cout << c << " ";
    }
    return 0;
}
/*
testcases
5
1 2
6
1 3 2
3 2 3
3 4 3
4 2 3
4 5 4
5 2 3
10

1 3 4 2
4
*/

我用简单的 bfs 方法写了一个代码。

写下每一步的信息可以解决这个问题。

如果有任何极端情况，请告诉我。