Question

我尝试使用BFS解决此问题，但在很多情况下它都卡住了。我想为给定的问题陈述提供有效的解决方案。

问题：给定总物理能量H和总距离D。给出了各种可用于行驶的速度以及相应的物理能量消耗。找到覆盖总距离D所需的最短时间，以确保总能耗不超过H。

以下是我编写的JAVA代码：

public class physicalEnergy {

    public static class nodes{
        int energy;
        int distance;
        int time;
        public nodes(int energy , int distance ,int time) {
            this.energy=energy;
            this.distance=distance;
            this.time=time;
        }
    }
    public static int getMinTime(int arr[] , HashMap<Integer,Integer> hm , int dist , int energy) {

        Arrays.sort(arr);

        Queue<nodes> q= new LinkedList<nodes>();
        for(int i=arr.length-1;i>=0;i--) {
            if(arr[i]==dist && hm.get(arr[i])<=energy) {
                return 1;
            }
            if(arr[i]<dist && hm.get(arr[i])<energy) {
                q.add(new nodes(hm.get(arr[i]),arr[i],1));
            }
        }
        while(!q.isEmpty()) {
            nodes temp= q.remove();

            for(int i=arr.length-1;i>=0;i--) {
                if(temp.distance+arr[i]==dist && temp.energy+hm.get(arr[i])<=energy) {
                    return temp.time+1;
                }
                if(temp.distance+arr[i]<dist && temp.energy+hm.get(arr[i])<energy) {
                    q.add(new nodes(temp.energy+hm.get(arr[i]),temp.distance+arr[i],temp.time+1));
                }

            }
        }
        return -1;

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int arr[]= { 10,30,50,20,70}; //speed per hour
        int energy[]= {2,25,35,15,50}; //energy per hour
        int distance= 70; //total distance
        int e= 45; //total energy should not exceed this limit
        HashMap<Integer,Integer> hm= new HashMap<Integer,Integer>();
        for(int i=0;i<arr.length;i++) {
            hm.put(arr[i],energy[i]);
        }
        int result= getMinTime(arr,hm,distance,e);
        System.out.println(result);

    }

}

我是一个初学者，所以我的代码可能不符合要求，但我只需要有关如何解决此类问题的想法。我也在考虑以实现0/1背包的方式来实现它。

Answer 1

我看不到“广度优先”搜索对于实现“有效的工作解决方案”的价值，您可以在其中使用简单的单循环解决方案：

//returned value is not necessarily int
public static double getMinTime(HashMap<Integer,Integer> speedEnerhgyMap
                                          , int dist , int energyLimit) {

    List<Integer> speeds = new ArrayList<>(speedEnerhgyMap.keySet());
    Collections.sort(speeds, Collections.reverseOrder()); //highest speed first

    //iterate starting at highest speed = shortest time
    for(int speed : speeds) {
        double time = (double)dist / speed; //code verbose to make it clear
        double energyUsed =  time * speedEnerhgyMap.get(speed);
        if(energyUsed <= energyLimit) {
            return time;
        }
    }

    return Double.NaN;
}

使用hm地图进行测试。

在不超出给定能量的情况下进行距离最小的时间

1 个答案: