Merge pull request matthewsamuel95#550 from CodeLogist/patch-1

Patch 1

Author: matthewsamuel95

Data Structures/Heap/Building_heap_from_arrays.cpp

@@ -0,0 +1,73 @@
+//Code By CodeLogist
+//Problem Also Present in Stanford University's Data Structure Course on Coursera.
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using std::vector;
+using std::cin;
+using std::cout;
+using std::swap;
+using std::pair;
+using std::make_pair;
+
+class HeapBuilder {
+ private:
+  vector<int> data_;
+  vector< pair<int, int> > swaps_;
+
+  void WriteResponse() const {
+    cout << swaps_.size() << "\n";
+    for (int i = 0; i < swaps_.size(); ++i) {
+      cout << swaps_[i].first << " " << swaps_[i].second << "\n";
+    }
+  }
+
+  void ReadData() {
+    int n;
+    cin >> n;
+    data_.resize(n);
+    for(int i = 0; i < n; ++i)
+      cin >> data_[i];
+  }
+
+    void GenerateSwaps() {
+        swaps_.clear();
+        for (int i = data_.size()/2; i >= 0; i--) {
+            ShiftDown(i);
+        }
+    }
+
+    void ShiftDown(int i){
+        int minindex=i;
+        int l=2*i+1;
+        if(l < data_.size() && data_[l] < data_[minindex])
+        {
+            minindex=l;
+        }
+        int r=2*i+2;
+        if(r < data_.size() && data_[r] < data_[minindex])
+            minindex=r;
+        if(minindex != i){
+            swap(data_[i], data_[minindex]);
+            swaps_.push_back(make_pair(i, minindex));
+            ShiftDown(minindex);
+        }
+    }
+
+
+ public:
+  void Solve() {
+    ReadData();
+    GenerateSwaps();
+    WriteResponse();
+  }
+};
+
+int main() {
+  std::ios_base::sync_with_stdio(false);
+  HeapBuilder heap_builder;
+  heap_builder.Solve();
+  return 0;
+}

Data Structures/Heap/Readme.md

@@ -0,0 +1,28 @@
+********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.