C# 最优最大旅行距离问题

给定最大行驶距离（向前和向后道路），返回使用最大行驶距离的路线，如果有多条相同的路线使用最大行驶距离，则返回多条路线

示例1

• 前进路线：

  [[13000]、[25000]、[34000]、[410000]、[58000]

• 反向路线：

  [[11000]、[23000]、[34000]]

• 最大行驶距离：

  11000

结果必须是：

[4,1]

和

[5,2]

，因为总行驶距离小于或等于最大距离

11000

示例2

• 前进路线：

  [[13000]、[25000]、[34000]、[410000]]

• 反向路线：

  [[12000]、[23000]、[34000]]

• 最大行驶距离：

  11000

结果必须为：

[2,3]

，因为总行驶距离为

9000

，小于或等于最大距离

我能够在O（forLength*backLength）中解决这个问题，如下代码所示：

static void Main(string[] args) {
    int[][] f = new int[5][];
    int[][] b = new int[3][];

    f[0] = new int[] { 1, 3000 };
    f[1] = new int[] { 2, 5000 };
    f[2] = new int[] { 3, 4000 };
    f[3] = new int[] { 4, 10000 };
    f[4] = new int[] { 5, 8000 };

    b[0] = new int[] { 1, 1000 };
    b[1] = new int[] { 2, 3000 };
    b[2] = new int[] { 3, 4000 };

    var result = sol(f, b, 11000);
}

public static List<List<int>> sol(int[][] f, int[][] b,int max) {
    List<List<int>> li = new List<List<int>>();
    int m = 0;
    for (int i = 0; i < f.Length; i++) {
        for (int j = 0; j < b.Length; j++) {
            if (f[i][1] + b[j][1] <= max) {
                li.Add(new List<int>() { f[i][0], b[j][0], f[i][1] + b[j][1] });
                if (m < f[i][1] + b[j][1]) {
                    m = f[i][1] + b[j][1];
                }
            }
        }
    }

    return li.Where(i => i[2] == m).ToList();
}

static void Main（字符串[]args）{
int[][]f=新的int[5][]；
int[]b=新的int[3][]；
f[0]=newint[]{1，3000}；
f[1]=newint[]{25000}；
f[2]=newint[]{34000}；
f[3]=新整数[]{4，10000}；
f[4]=新整数[]{5，8000}；
b[0]=newint[]{11000}；
b[1]=newint[]{23000}；
b[2]=newint[]{34000}；
var结果=sol（f，b，11000）；
}
公共静态列表sol（int[]f，int[]b，int max）{
List li=新列表（）；
int m=0；
对于（int i=0；i

---

有人能帮我提高时间复杂度方面的效率吗？

也许我可以给你一份解决方案草案：

• 让我们将“向前”列表命名为

  fwList

  ，“向后”列表命名为

  bwList

  。每个元素按顺序包含一个键和一个值

• 对元素的部分（O（N.ln（N））时间复杂度）使用合并排序或堆排序按升序对两个列表进行排序

• 对于

  bwList

  （我们称之为

  bvelem

  ）的每个元素，在

  fwList

  （我们称之为

  ID

  ）中查找索引，其中的总和变得太长（

  bvelem+fwList[ID]>11000

  ）。然后

  [bvelem.key，fwList[ID-1]。key]

  是解决方案的一部分

• 将

  bwList

  的每个元素的结果串联在一起应该会形成你的列表，如果我想得很清楚，你应该有一个O（bwLength*（fwLength）^a）时间复杂度，其中a<1（我甚至打赌O（bwLength*ln（fwLength）））

---

我认为可以在此基础上对算法进行优化。

尽管尝试，但我无法理解您的问题定义。您应该提出您的问题，这似乎更合适。@GonenI您现在可以检查它吗？您是在寻找全新的代码还是要修改此代码？@Fildor请现在检查它