fork download
copy 
  1. #include <iostream>
  2. #include <map>
  3. #include <vector>
  4. #include <string>
  5. #include <algorithm>
  6. #include <sstream>
  7. #include <iomanip>
  8. #include <climits>
  9.  
  10. using namespace std;
  11.  
  12. // Helper function: Convert time in "hh:mmAM/PM" to minutes since midnight
  13. int convertTimeToMinutes(const string& time) {
  14.     int hours = stoi(time.substr(0, time.find(':')));
  15.     int minutes = stoi(time.substr(time.find(':') + 1, 2));
  16.     string ampm = time.substr(time.size() - 2);
  17.     if (ampm == "PM" && hours != 12) hours += 12;
  18.     if (ampm == "AM" && hours == 12) hours = 0;
  19.     return hours * 60 + minutes;
  20. }
  21.  
  22. // Function to process logs and organize entries and exits
  23. map<int, map<int, pair<vector<int>, vector<int>>>> processLogs(
  24.     const vector<tuple<int, string, string, string>>& logs) {
  25.  
  26.     map<int, map<int, pair<vector<int>, vector<int>>>> employeeLogs;
  27.  
  28.     for (const auto& [employeeID, action, location, time] : logs) {
  29.         // Filter only logs with "room" in the location
  30.         if (location.find("room") == string::npos) continue;
  31.  
  32.         int roomNumber = stoi(location.substr(4)); // Extract room number
  33.         int timeInMinutes = convertTimeToMinutes(time);
  34.  
  35.         if (action == "enters") {
  36.             employeeLogs[employeeID][roomNumber].first.push_back(timeInMinutes);
  37.         } else if (action == "exits") {
  38.             employeeLogs[employeeID][roomNumber].second.push_back(timeInMinutes);
  39.         }
  40.     }
  41.  
  42.     // Sort entries and exits for every room
  43.     for (auto& [employeeID, rooms] : employeeLogs) {
  44.         for (auto& [roomNumber, logs] : rooms) {
  45.             sort(logs.first.begin(), logs.first.end());  // Sort entries
  46.             sort(logs.second.begin(), logs.second.end()); // Sort exits
  47.         }
  48.     }
  49.  
  50.     return employeeLogs;
  51. }
  52.  
  53. // Function to calculate work done and consistency
  54. pair<int, bool> calculateWorkDoneAndConsistency(
  55.     const map<int, map<int, pair<vector<int>, vector<int>>>>& employeeLogs,
  56.     map<int, map<int, int>>& workDonePerRoom, int employeeID) {
  57.  
  58.     int totalWorkDone = 0;
  59.     bool isInconsistent = false;
  60.  
  61.     for (const auto& [roomNumber, logs] : employeeLogs.at(employeeID)) {
  62.         const auto& entries = logs.first;
  63.         const auto& exits = logs.second;
  64.  
  65.         vector<bool> entryUsed(entries.size(), false);
  66.         vector<bool> exitUsed(exits.size(), false);
  67.  
  68.         int roomWorkDone = 0;
  69.  
  70.         // Map exits to the nearest prior entry
  71.         for (size_t j = 0; j < exits.size(); ++j) {
  72.             for (size_t i = 0; i < entries.size(); ++i) {
  73.                 if (!entryUsed[i] && entries[i] < exits[j]) {
  74.                     roomWorkDone += exits[j] - entries[i];
  75.                     entryUsed[i] = true;
  76.                     exitUsed[j] = true;
  77.                     break;
  78.                 }
  79.             }
  80.         }
  81.  
  82.         // Check if unmatched entries or exits remain
  83.         if (any_of(entryUsed.begin(), entryUsed.end(), [](bool used) { return !used; }) ||
  84.             any_of(exitUsed.begin(), exitUsed.end(), [](bool used) { return !used; })) {
  85.             isInconsistent = true;
  86.         }
  87.  
  88.         totalWorkDone += roomWorkDone;
  89.         workDonePerRoom[employeeID][roomNumber] = roomWorkDone;
  90.     }
  91.  
  92.     return {totalWorkDone, isInconsistent};
  93. }
  94.  
  95. // Main function
  96. int main() {
  97.     int n;
  98.     cin >> n;
  99.  
  100.     vector<tuple<int, string, string, string>> logs(n);
  101.     for (int i = 0; i < n; ++i) {
  102.         int employeeID;
  103.         string action, location, time;
  104.         cin >> employeeID >> action >> location >> time;
  105.         logs[i] = {employeeID, action, location, time};
  106.     }
  107.  
  108.     int suspectID;
  109.     cin >> suspectID;
  110.  
  111.     // Step 1: Sort logs and organize data
  112.     sort(logs.begin(), logs.end(), [](const auto& a, const auto& b) {
  113.         if (get<0>(a) != get<0>(b)) return get<0>(a) < get<0>(b);
  114.         return get<2>(a) < get<2>(b);
  115.     });
  116.     auto employeeLogs = processLogs(logs);
  117.  
  118.     // Step 2: Calculate work done and consistency for each employee
  119.     map<int, map<int, int>> workDonePerRoom;
  120.     map<int, pair<int, bool>> results; // {EmployeeID: {TotalWorkDone, IsInconsistent}}
  121.  
  122.     for (const auto& [employeeID, _] : employeeLogs) {
  123.         results[employeeID] = calculateWorkDoneAndConsistency(employeeLogs, workDonePerRoom, employeeID);
  124.     }
  125.  
  126.     // Step 3: Print individual employee status
  127.     cout << "Employee Status:\n";
  128.     for (const auto& [employeeID, result] : results) {
  129.         const auto& [totalWorkDone, isInconsistent] = result;
  130.         cout << "Employee ID: " << employeeID << "\n";
  131.         cout << "  Consistency: " << (isInconsistent ? "Inconsistent" : "Consistent") << "\n";
  132.         cout << "  Total Work Done: " << totalWorkDone << " minutes\n";
  133.         cout << "  Work Done by Room:\n";
  134.         for (const auto& [room, work] : workDonePerRoom[employeeID]) {
  135.             cout << "    room" << room << ": " << work << " minutes\n";
  136.         }
  137.         cout << "\n";
  138.     }
  139.  
  140.     // Step 4: Determine result for suspect
  141.     bool suspectInconsistent = results[suspectID].second;
  142.     int suspectWork = results[suspectID].first;
  143.     int leastWork = INT_MAX;
  144.     bool otherInconsistentWithLessWork = false;
  145.  
  146.     for (const auto& [employeeID, result] : results) {
  147.         const auto& [workDone, isInconsistent] = result;
  148.         if (workDone < leastWork) leastWork = workDone;
  149.         if (employeeID != suspectID && isInconsistent && workDone < suspectWork) {
  150.             otherInconsistentWithLessWork = true;
  151.         }
  152.     }
  153.  
  154.     if (suspectInconsistent || otherInconsistentWithLessWork) {
  155.         cout << "Cannot be determined\n";
  156.     } else if (suspectWork == leastWork) {
  157.         cout << "Yes\n";
  158.     } else {
  159.         cout << "No\n";
  160.     }
  161.  
  162.     return 0;
  163. }
  164.  
Success #stdin #stdout 0s 5272KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Employee Status:
Yes
https://ideone.com/iF8ShG
language:
C++ (gcc 8.3)
created:
4 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!