सभी की जाँच करें - स्काला
अनुमानित स्कोर: 2 मी ^ एन
मैं प्रत्येक मशीन से शुरू करता हूं और डेडलाइन को पूरा करने वाली विभिन्न मशीनों के साथ कार्यों के माध्यम से सभी क्रमपरिवर्तन बनाने के लिए सभी कार्यों पर पुनरावृति करता हूं। मतलब अगर सब कुछ समय पर होता है तो मुझे 2 मशीनों और 3 कार्यों के साथ 9 संभावित रास्ते मिलेंगे। (m ^ n) बाद में, मैं सबसे कम लागत के साथ रास्ता लेता हूं।
इनपुट इस तरह संरचित है (-> भागों की व्याख्या करता है और इस तरह दर्ज नहीं किया जाना चाहिए):
M_1:5 3 5 4;M_2:4 2 7 5 --> time
M_1:5 4 2 6;M_2:3 7 3 3 --> cost
M_1:M_1}0 M_2}1;M_2:M_1}2 M_2}0 --> switch itme
M_1:M_1}0 M_2}2;M_2:M_1}1 M_2}0 --> switch cost
5 10 15 20 --> deadlines
और यहाँ कोड है:
package Scheduling
import scala.io.StdIn.readLine
case class Cost(task: Map[String, List[Int]])
case class Switch(machine: Map[String, Map[String, Int]])
case class Path(time: Int, cost: Int, machine: List[String])
object Main {
def main(args: Array[String]) {
val (machines, cost_time, cost_money, switch_time, switch_money, deadlines) = getInput
val s = new Scheduler(machines, cost_time, cost_money, switch_time, switch_money, deadlines)
s.schedule
}
def getInput(): (List[String], Cost, Cost, Switch, Switch, List[Int]) = {
val cost_time = Cost(readLine("time to complete task").split(";").map{s =>
val parts = s.split(":")
(parts(0) -> parts(1).split(" ").map(_.toInt).toList)
}.toMap)
val cost_money = Cost(readLine("cost to complete task").split(";").map{s =>
val parts = s.split(":")
(parts(0) -> parts(1).split(" ").map(_.toInt).toList)
}.toMap)
val switch_time = Switch(readLine("time to switch").split(";").map{s =>
val parts = s.split(":")
(parts(0) -> parts(1).split(" ").map{t =>
val entries = t.split("}")
(entries(0) -> entries(1).toInt)
}.toMap)
}.toMap)
val switch_money = Switch(readLine("time to switch").split(";").map{s =>
val parts = s.split(":")
(parts(0) -> parts(1).split(" ").map{t =>
val entries = t.split("}")
(entries(0) -> entries(1).toInt)
}.toMap)
}.toMap)
val deadlines = readLine("deadlines").split(" ").map(_.toInt).toList
val machines = cost_time.task.keys.toList
(machines, cost_time, cost_money, switch_time, switch_money, deadlines)
}
}
class Scheduler(machines: List[String], cost_time: Cost, cost_money: Cost, switch_time: Switch, switch_money: Switch, deadlines: List[Int]) {
def schedule() {
var paths = List[Path]()
var alternatives = List[(Int, Path)]()
for (i <- machines) {
if (cost_time.task(i)(0) <= deadlines(0)) {
paths = paths ::: List(Path(cost_time.task(i)(0), cost_money.task(i)(0), List(i)))
}
}
val allPaths = deadlines.zipWithIndex.tail.foldLeft(paths)((paths, b) => paths.flatMap(x => calculatePath(x, b._1, b._2)))
if (allPaths.isEmpty) {
println("It is not possible")
} else {
println(allPaths.minBy(p=>p.cost).machine)
}
}
def calculatePath(prev: Path, deadline: Int, task: Int): List[Path] = {
val paths = machines.map(m => calculatePath(prev, task, m))
paths.filter(p => p.time <= deadline)
}
def calculatePath(prev: Path, task: Int, machine: String): Path = {
val time = prev.time + switch_time.machine(prev.machine.last)(machine) + cost_time.task(machine)(task)
val cost = prev.cost + switch_money.machine(prev.machine.last)(machine) + cost_money.task(machine)(task)
Path(time, cost, prev.machine :+ machine)
}
}
मुझे भी पीछे से शुरू करने का विचार था। चूंकि आप हमेशा सबसे कम लागत वाली एक मशीन का चयन कर सकते हैं यदि समय छोटा है तो पिछली समय सीमा से लेकर नए में अंतर। लेकिन यह अधिकतम रनटाइम को कम नहीं करेगा यदि बेहतर लागत के साथ कार्य में अधिक समय लगता है तो अंतिम समय सीमा समाप्त हो जाती है।
अपडेट करें
======
यहाँ एक और सेट अप है। समय:
M_1 2 2 2 7
M_2 1 8 5 10
लागत:
M_1 4 4 4 4
M_2 1 1 1 1
स्विच समय:
M_1 M_2
M_1 0 2
M_2 6 0
स्विच लागत:
M_1 M_2
M_1 0 2
M_2 2 0
समय सीमा:
5 10 15 20
मेरे कार्यक्रम में इनपुट के रूप में:
M_1:2 2 2 7;M_2:1 8 5 10
M_1:4 4 4 4;M_2:1 1 1 1
M_1:M_1}0 M_2}2;M_2:M_1}6 M_2}0
M_1:M_1}0 M_2}2;M_2:M_1}2 M_2}0
5 10 15 20
इस एक के दो समाधान हैं: समय: 18, लागत: 15, पथ: सूची (M_1, M_1, M_1, M_2) समय: 18, लागत: 15, पथ: सूची (M_2, M_1, M_1, M_1)
जो सवाल उठाता है कि इसे कैसे संभाला जाना चाहिए। क्या सभी को मुद्रित या सिर्फ एक होना चाहिए? और क्या होगा अगर समय अलग होगा? क्या सबसे कम लागत वाली और कोई छूटी हुई समय सीमा पर्याप्त नहीं है या यह भी सबसे कम समय वाली होनी चाहिए?