20231224

ACMOJ-1448.hpp

@@ -0,0 +1,130 @@
+#ifndef _SJTU_CPP_FINAL_CPU_HPP_
+#define _SJTU_CPP_FINAL_CPU_HPP_
+
+#include <cassert>
+#include <vector>
+
+#include "task.hpp"
+
+using namespace std;
+
+typedef unsigned int uint;
+
+namespace sjtu {
+// CPU base class, modifications is not allowed.
+class CPU {
+ protected:
+  CPUState state;
+  vector<Task> tasks;
+
+ public:
+  CPU() : tasks() { state = idle; }
+
+  // Add a new task.
+  int addTask(const Task &t) {
+    tasks.push_back(t);
+    return 1;
+  }
+
+  // Change the priority of one process, return 1 if success and return 0 if
+  // fail.
+  int changePriority(uint task_id, uint priority) {
+    for (auto &task : tasks)
+      if (task.task_id == task_id) {
+        task.priority = priority;
+        return 1;
+      }
+    return 0;
+  }
+
+  virtual pair<CPUState, uint> run() = 0;
+
+  virtual ~CPU() = default;
+};
+
+// FCFS method based CPU.
+class CPU_FCFS : public CPU {
+  // TODO: complete the FCFS method.
+ public:
+  pair<CPUState, uint> run() override {
+    bool has_opt = false;
+    for (int i = 0; i < tasks.size(); i++) {
+      if (tasks[i].time > 0) {
+        has_opt = true;
+        state = CPUState::busy;
+        tasks[i].time--;
+        return std::make_pair(CPUState::busy, tasks[i].task_id);
+      }
+    }
+    state = CPUState::idle;
+    return std::make_pair(CPUState::idle, 0);
+  }
+  ~CPU_FCFS() override = default;
+};
+
+// SRTF method based CPU.
+class CPU_SRTF : public CPU {
+  // TODO: complete the SRTF method.
+ public:
+  pair<CPUState, uint> run() override {
+    bool has_opt = false;
+    int least_time = -1;
+    for (int i = 0; i < tasks.size(); i++) {
+      if (tasks[i].time > 0) {
+        has_opt = true;
+        if (least_time == -1)
+          least_time = tasks[i].time;
+        else
+          least_time =
+              (tasks[i].time < least_time) ? tasks[i].time : least_time;
+      }
+    }
+    if (!has_opt) {
+      state = CPUState::idle;
+      return std::make_pair(CPUState::idle, 0);
+    }
+    for (int i = 0; i < tasks.size(); i++) {
+      if (tasks[i].time == least_time) {
+        state = CPUState::busy;
+        tasks[i].time--;
+        return std::make_pair(CPUState::busy, tasks[i].task_id);
+      }
+    }
+  }
+  ~CPU_SRTF() override = default;
+};
+
+// priority method based CPU.
+class CPU_PRIORITY : public CPU {
+  // TODO: complete the priority method.
+ public:
+  pair<CPUState, uint> run() override {
+    bool has_opt = false;
+    int highest_pri = -1;
+    for (int i = 0; i < tasks.size(); i++) {
+      if (tasks[i].time > 0) {
+        has_opt = true;
+        if (highest_pri == -1)
+          highest_pri = tasks[i].priority;
+        else
+          highest_pri = (tasks[i].priority < highest_pri) ? tasks[i].priority
+                                                          : highest_pri;
+      }
+    }
+    if (!has_opt) {
+      state = CPUState::idle;
+      return std::make_pair(CPUState::idle, 0);
+    }
+    for (int i = 0; i < tasks.size(); i++) {
+      if (tasks[i].priority == highest_pri && tasks[i].time > 0) {
+        state = CPUState::busy;
+        tasks[i].time--;
+        return std::make_pair(CPUState::busy, tasks[i].task_id);
+      }
+    }
+  }
+  ~CPU_PRIORITY() override = default;
+};
+}  // namespace sjtu
+
+#endif