Question

这是与学校有关的问题，虽然不完全是家庭作业。

我正在学习算法课程，目前正在编写Cormen's Introduction to Algorithms本书的第15章。我已经成功地找到了本书中大多数算法的大量在线示例，我通常可以找到某种类型的Java applet或其他程序，它们可以很好地显示算法的工作方式。

例外情况是第15章（动态规划）中的装配线调度。

是否有人知道提供装配线调度算法的更多示例或可视化的在线资源？

Answer 1

如果您搜索技术的示例/可视化而不是特定问题，我认为您会有更好的运气...即搜索动态编程。

TopCoder上可能有一些不错的教程“dynamic programming site:topcoder.com”。

Answer 2

如果你想要解决方案，我写了一个练习。这是动态编程的一个例子。这意味着您的解决方案会避免重复计算。如果问题可以分为子单元，并且在某些情况下会重复这些子单元，则不必多次解决它们。在这种情况下，您将在第一次之后存储解决方案，并在以后重复使用。

package com.zafar;

import java.util.Scanner;

public class AssemblyLineProblem {
    public static void main(String arg[]){
        Scanner scanner =new Scanner(System.in);

    int numberOfStations=scanner.nextInt();
    Station firstLine[]=new Station[numberOfStations];
    Station secondLine[]=new Station[numberOfStations];

    for(int i=0;i<numberOfStations;i++){
        firstLine[i]=new Station(i,scanner.nextInt());
        firstLine[i].setIndex(i);
        firstLine[i].setTransferCost(scanner.nextInt());
        firstLine[i].setNameOfLine("line 1");
    }
    for(int i=0;i<numberOfStations;i++){
        secondLine[i]=new Station(i,scanner.nextInt());
        secondLine[i].setIndex(i);
        secondLine[i].setTransferCost(scanner.nextInt());           
        secondLine[i].setNameOfLine("line 2");
    }
    int entryCostLine1=scanner.nextInt();
    int entryCostLine2=scanner.nextInt();
    Station beginStation=findOptimalRoute(numberOfStations, firstLine, secondLine, entryCostLine1, entryCostLine2);
    System.out.println("The optimal route is");
    print(beginStation);
    scanner.close();

}
public static void print(Station station){
    if(station==null)
        return;
    System.out.println(station.getNameOfLine()+", station "+station.getIndex()+", cost from here: "+station.getOptimalCostFromThisStation());       
    print(station.getNextOptimalStation());
}

public static Station findOptimalRoute(int numberOfStations,
        Station[] firstLine, Station[] secondLine, int entryCostLine1,
        int entryCostLine2) {
    for(int i=numberOfStations-1;i>=0;i--){
        if(i==numberOfStations-1)
        {
            firstLine[i].setOptimalCostFromThisStation(firstLine[i].getTransferCost());
            secondLine[i].setOptimalCostFromThisStation(secondLine[i].getTransferCost());
        }else{
            calculateOptimalStation(firstLine, secondLine, i);
            calculateOptimalStation(secondLine, firstLine, i);                          
        }               
    }
    if((entryCostLine1+firstLine[0].getCost()+firstLine[0].getOptimalCostFromThisStation())>= (entryCostLine2+secondLine[0].getCost()+secondLine[0].getOptimalCostFromThisStation())){
        return secondLine[0];
    }else
        return firstLine[0];

}
public static void calculateOptimalStation(Station[] currentLine, Station[] otherLine, int indexOfCurrentStation){

    int costOnContinuingOnSameLine= (currentLine[indexOfCurrentStation+1].getCost()+currentLine[indexOfCurrentStation+1].getOptimalCostFromThisStation());

    int costOnSwitchingLines=(currentLine[indexOfCurrentStation].getTransferCost()+otherLine[indexOfCurrentStation+1].getCost()+otherLine[indexOfCurrentStation+1].getOptimalCostFromThisStation()) ;
    if((costOnContinuingOnSameLine  <= costOnSwitchingLines)){
        currentLine[indexOfCurrentStation].setOptimalCostFromThisStation(costOnContinuingOnSameLine);
        currentLine[indexOfCurrentStation].setNextOptimalStation(currentLine[indexOfCurrentStation+1]);
    }
    else{
        currentLine[indexOfCurrentStation].setOptimalCostFromThisStation(costOnSwitchingLines);
        currentLine[indexOfCurrentStation].setNextOptimalStation(otherLine[indexOfCurrentStation+1]);
    }


}

}

class Station{
    private String nameOfLine;
    private int index;
    private int cost;
    private int transferCost;
    private Station nextOptimalStation;
    private int optimatCostFromThisStation=0;
    public Station(int index, int cost){
        this.index=index;
        this.cost=cost;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
    public int getCost() {
        return cost;
    }
    public void setCost(int cost) {
        this.cost = cost;
    }
    public Station getNextOptimalStation() {
        return nextOptimalStation;
    }
    public void setNextOptimalStation(Station nextOptimalStation) {
        this.nextOptimalStation = nextOptimalStation;
    }
    public int getTransferCost() {
        return transferCost;
    }
    public void setTransferCost(int transferCost) {
        this.transferCost = transferCost;
    }
    public int getOptimalCostFromThisStation() {
        return optimatCostFromThisStation;
    }
    public void setOptimalCostFromThisStation(int optimatCostFromThisStation) {
        this.optimatCostFromThisStation = optimatCostFromThisStation;
    }
    public String getNameOfLine() {
        return nameOfLine;
    }
    public void setNameOfLine(String nameOfLine) {
        this.nameOfLine = nameOfLine;
    }

}

输入： 6

7 2 9 3 3 1 4 3 8 4 4 3

8 2 5 1 6 2 4 2 5 1 7 2

2 4

输出：

最佳路线是

第1行，第0站，费用从这里开始：29

第2行，第1站，费用从这里开始：22

第1行，第2站，费用从这里开始：18

第2行，第3站，费用从这里开始：13

第2行，第4站，费用从这里开始：8

第1行，第5站，费用从这里开始：3

其他资源：https://parasol.tamu.edu/~welch/teaching/411.f14/dp.pdf

我在哪里可以找到Cormen装配线调度的在线示例？

2 个答案: