Question

我正在写一个问题来解决工作时间表，但我很难理解如何。

The Wood Shop积压了世界着名摇椅的订单（每张订单1把椅子）。有几个制作手工Baber摇椅的步骤（例如，切割木片，组装，打磨，涂抹污渍，并应用清漆）。

制作椅子所需的总时间为1周。但是，由于椅子的销售方式不同地区和各种市场，每个订单的利润额可能不同。此外，还有一个相关的截止日期每个订单。公司只有在截止日期前才能获利;否则，利润为0.

编写一个程序，确定最大化利润的订单的最佳时间表。输入文件将包含一个或多个测试用例。测试用例中的第一行将包含一个整数n（0 n 1000），表示待处理的订单数量。

n的值为0表示输入文件的结尾。接下来的n行每行包含3个正整数。第一个整数i是订单号。

给定的所有订单号测试用例是独一无二的第二个整数表示从现在到i截止日期的周数日订购。该第三个整数表示如果满足i的截止日期，公司将获得的利润额日顺序。

我要求的是如何解决此问题的算法。

对于输入文件中的每个测试用例，输出文件应输出一行，报告由此产生的利润额以最佳顺序完成订单。

Example Input File (sched.in)
7
1 3 40
2 1 35
3 1 30
4 3 25
5 1 20
6 3 15
7 2 10
4
3054 2 30
4099 1 35
3059 2 25
2098 1 40
0
Example Output File (sched.out)
100
70

Answer 1

有很多方法可以解决工作车间的问题。首先阅读维基百科条目，然后选择一本关于算法设计的好书。你的教授可能会推荐一个。我怀疑动态编程是解决这个问题的好方法，但也会有其他方法。

这是一个难题，所以不要指望一个简单的答案。许多人仍在研究如何有效地解决这个问题。

Answer 2

您的问题的假设不完整。要知道你每周可以做多少把椅子。也许你可以一次完成所有工作。但是我们假设你只能做一个。解决方案是这样的。

根据Cameron Skinner的非常聪明的评论，我改变了对此的回答：

public class tarea
{         
    List<input> datas = new ArrayList<input>();

     class input
     {
         public int profit;
         public int deadline;
         public int index1;
         public int index2;
         public int sum() {return index1+index2;}
        /**
         * @param profit
         * @param deadline
         */
        public input(int deadline, int profit)
        {
            super();
            this.profit = profit;
            this.deadline = deadline;
        } 

     }


     public void readData1()
     {
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(1,1));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
         this.datas.add(new input(10,1000));
     }


     public void readData2()
     {/*
         3 40
         2 1 35
         3 1 30
         4 3 25
         5 1 20
         6 3 15
         7 2 10 */

         this.datas.add(new input(3,40));
         this.datas.add(new input(1,35));
         this.datas.add(new input(1,30));
         this.datas.add(new input(3,25));
         this.datas.add(new input(1,20));
         this.datas.add(new input(3,15));
         this.datas.add(new input(2,10));
     }

     public void readData3()
     {/*
     2 30
     4099 1 35
     3059 2 25
     2098 1 40*/

         this.datas.add(new input(2,30));
         this.datas.add(new input(1,35));
         this.datas.add(new input(2,25));
         this.datas.add(new input(1,40));
     }



     @SuppressWarnings("unchecked")
    public void sortbyprofit(List<input> datas)
     {
         Collections.sort(datas, new Comparator() {

            public int compare(Object o1, Object o2)
            {
                if(((input)(o1)).profit < ((input)(o2)).profit)
                    return 1;
                else if(((input)(o1)).profit == ((input)(o2)).profit)
                    return 0;
                else return -1;
            }});
     }

     @SuppressWarnings("unchecked")
     public void sortbydeadline(List<input> datas)
      {
          Collections.sort(datas, new Comparator() {

             public int compare(Object o1, Object o2)
             {
                 if(((input)(o1)).deadline > ((input)(o2)).deadline)
                     return 1;
                 else if(((input)(o1)).deadline == ((input)(o2)).deadline)
                     return 0;
                 else return -1;
             }});
      }


     @SuppressWarnings("unchecked")
     public void sortbySum(List<input> datas)
      {
          Collections.sort(datas, new Comparator() {

             public int compare(Object o1, Object o2)
             {
                 if(((input)(o1)).sum() > ((input)(o2)).sum())
                     return 1;
                 else if(((input)(o1)).sum() == ((input)(o2)).sum())
                     return 0;
                 else return -1;
             }});
      }


    @SuppressWarnings("unchecked")
    public static void main(String[] args)
    {
        tarea tsk = new tarea();
        //tsk.readData1();
        //tsk.readData2();
        tsk.readData3();


        while (tsk.datas.size() > 0)
        {
            //sort by profit
            tsk.sortbyprofit(tsk.datas);
            int idx0 = 1;
            //assign index
            for (input data : tsk.datas)
            {
                data.index1 = idx0;
                idx0++;
            }

            //sort by deadline
            tsk.sortbydeadline(tsk.datas);
            int idx2 = 1;
            for (input data : tsk.datas)
            {
                data.index2 = idx2;
                idx2++;
            }

            //sort by sum and profit
            tsk.sortbySum(tsk.datas);

            List<input> tmpdatas = new ArrayList<input>();
            int valsum = tsk.datas.get(0).sum();
            for (input data : tsk.datas)
            {
                if (data.sum() == valsum)
                    tmpdatas.add(data);
            }            
            tsk.sortbyprofit(tmpdatas);

            //get the first one as result
            input thedata = tmpdatas.get(0);

            System.out.println("result ===> " + thedata.profit);

            tsk.datas.remove(thedata);
            tmpdatas = new ArrayList<input>();
            for (input data : tsk.datas)
            {
                data.deadline--;
                if (data.deadline > 0)
                    tmpdatas.add(data);
            }
            tsk.datas = tmpdatas;
        }


    }


}

Answer 3

欢迎来到NP完整规划问题的精彩世界。一旦扩展，就无法在我们的生命周期中找到最佳解决方案。但这并不重要，你只需要在给定的时间内找到最佳解决方案（击败人类规划者和其他软件程序）。

不要自己编写这些算法（除非您是具有多年经验的专家）。使用专门解决这些问题的现成库，例如：

Drools Planner（开源，ASL，java）
openTS
cpsolver

Answer 4

好的，Java不是问题所在。考虑算法，而不是专注于语言。

这种“味道”就像有dynamic programming解决方案的东西，但是从这个方面我推断你是一个初学者，所以一个详尽的搜索可能更容易订单数量合理。在详尽的搜索中，您只需列出每个可能的订单并保存最有利可图的订单。

Java中的作业调度问题

4 个答案: