在特定成本内找到一条路

如何解决在特定成本内找到一条路

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

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

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

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

源是节点A，目的地是节点B；所需费用为10。从A到B共有三种路径：

 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长。

希望我清楚地解释了我的问题。 是否有解决此问题的已发布算法或方法？

谢谢。

解决方法

我不认为该问题有众所周知的算法。

让我向您展示我的摘录。

#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方法编写了代码。

撰写有关每个步骤的信息将解决此问题。

让我知道是否有极端情况。