Merge pull request matthewsamuel95#552 from CodeLogist/patch-3

Patch 3

Author: matthewsamuel95

Data Structures/Priority Queue/Parallel_processing\job_queue.cpp

@@ -0,0 +1,91 @@
+  #include <iostream>
+#include <vector>
+#include <algorithm>
+#include <queue>
+
+using std::vector;
+using std::cin;
+using std::cout;
+using std::priority_queue;
+
+
+class worker
+{
+public:
+    long long int id;
+    long long int next_free_time;
+    worker(long long int id)
+    {
+        this->id=id;
+        next_free_time=0;
+    }
+};
+
+struct compare{
+    bool operator()(const worker &w1, const worker &w2) const {
+		if(w1.next_free_time == w2.next_free_time)
+			return w1.id > w2.id;
+		else
+            return w1.next_free_time > w2.next_free_time;
+    }
+};
+
+class JobQueue {
+ private:
+  long long int num_workers_;
+  vector<long long int> jobs_;
+
+  vector<long long int> assigned_workers_;
+  vector<long long int> start_times_;
+
+  void WriteResponse() const {
+    for (long long int i = 0; i < jobs_.size(); ++i) {
+      cout << assigned_workers_[i] << " " << start_times_[i] << "\n";
+    }
+  }
+
+  void ReadData() {
+    long long int m;
+    cin >> num_workers_ >> m;
+    jobs_.resize(m);
+    for(long long int i = 0; i < m; ++i)
+      cin >> jobs_[i];
+  }
+
+  void AssignJobs() {
+    // TODO: replace this code with a faster algorithm.
+    assigned_workers_.resize(jobs_.size());
+    start_times_.resize(jobs_.size());
+    priority_queue <worker, vector<worker>, compare> pq;
+    long long int i=0;
+    for(i=0;i<num_workers_;i++)
+    {
+        pq.push(worker(i));
+    }
+
+    for (i = 0; i < jobs_.size(); ++i) {
+      worker free_thread = pq.top();
+      pq.pop();
+      assigned_workers_[i] = free_thread.id;
+      start_times_[i] = free_thread.next_free_time;
+      free_thread.next_free_time += jobs_[i];
+      pq.push(free_thread);
+    }
+  }
+
+ public:
+  void Solve() {
+    ReadData();
+    AssignJobs();
+    WriteResponse();
+  }
+};
+
+
+
+int main() {
+  std::ios_base::sync_with_stdio(false);
+  JobQueue job_queue;
+  job_queue.Solve();
+  return 0;
+}

Data Structures/Priority Queue/Readme.md

@@ -0,0 +1,27 @@
+********Problem Description:********
+
+******Task:******
+
+You have a program which is parallelized and uses 𝑛 independent threads to process the given list
+of 𝑚 jobs. Threads take jobs in the order they are given in the input. If there is a free thread,
+it immediately takes the next job from the list. If a thread has started processing a job, it doesn’t
+interrupt or stop until it finishes processing the job. If several threads try to take jobs from the list
+simultaneously, the thread with smaller index takes the job. For each job you know exactly how long
+will it take any thread to process this job, and this time is the same for all the threads. You need to
+determine for each job which thread will process it and when will it start processing.
+
+******Input Format:******
+
+The first line of the input contains integers 𝑛 and 𝑚.
+The second line contains 𝑚 integers 𝑡𝑖 — the times in seconds it takes any thread to process 𝑖-th job.
+The times are given in the same order as they are in the list from which threads take jobs.
+Threads are indexed starting from 0.
+Constraints. 1 ≤ 𝑛 ≤ 105
+; 1 ≤ 𝑚 ≤ 105
+; 0 ≤ 𝑡𝑖 ≤ 109
+.
+******Output Format:******
+
+Output exactly 𝑚 lines. 𝑖-th line (0-based index is used) should contain two spaceseparated
+integers — the 0-based index of the thread which will process the 𝑖-th job and the time in
+seconds when it will start processing that job.