did some leetcode problems and tried another contest

Author: Github11200

Contests/DMOJ Contests/OTHS Coding Competition 3 (CCC)/S1.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link:
+  Points:
+******************************************/
+
+struct Point
+{
+  int x;
+  int y;
+  int z;
+};
+
+void the5thLaboratory()
+{
+  Point labCoordinates;
+  scanf("%d %d %d", &labCoordinates.x, &labCoordinates.y, &labCoordinates.z);
+
+  int N;
+  scanf("%d", &N);
+
+  Point hidingSpotCoordinates;
+  double minimumTime = -1;
+  double time = 0;
+  double distance = 0;
+  for (int i = 0; i < N; ++i)
+  {
+    scanf("%d %d %d", &hidingSpotCoordinates.x, &hidingSpotCoordinates.y, &hidingSpotCoordinates.z);
+
+    if (hidingSpotCoordinates.z == labCoordinates.z)
+    {
+      // Just calculate the triangle distance
+      distance = hypot(abs(hidingSpotCoordinates.x - labCoordinates.x), abs(hidingSpotCoordinates.y - labCoordinates.y));
+      time = distance / 2;
+    }
+    else if (hidingSpotCoordinates.z < labCoordinates.z)
+    {
+      // Straight line distance
+      distance = hypot(abs(hidingSpotCoordinates.x - labCoordinates.x), abs(hidingSpotCoordinates.y - labCoordinates.y));
+      time += distance / 2;
+
+      // Now we climb up
+      distance = abs(labCoordinates.z - hidingSpotCoordinates.z);
+      time += distance;
+    }
+    else
+    {
+      // Go all the way down
+      distance = abs(hidingSpotCoordinates.z - labCoordinates.z);
+      time += distance / 4;
+
+      // Get the distance remaining
+      distance = hypot(abs(hidingSpotCoordinates.x - labCoordinates.x), abs(hidingSpotCoordinates.y - labCoordinates.y)) - (3 * time);
+
+      // Travel on flat ground
+      time += abs(distance) / 2;
+    }
+
+    if (minimumTime == -1)
+      minimumTime = time;
+    else
+      minimumTime = min(minimumTime, time);
+  }
+
+  printf("%f\n", minimumTime);
+}
+
+int main()
+{
+  the5thLaboratory();
+  return 0;
+}

Contests/DMOJ Contests/OTHS Coding Competition 3 (CCC)/S2.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link:
+  Points:
+******************************************/
+
+void togetherForever()
+{
+  int N;
+  scanf("%d", &N);
+
+  vector<int> a(N), b(N);
+  for (int i = 0; i < N; ++i)
+    scanf("%d", &a[i]);
+  for (int i = 0; i < N; ++i)
+    scanf("%d", &b[i]);
+
+  vector<pair<int, int>> swaps;
+  for (int i = 0; i < N; ++i)
+  {
+    if (a[i] != b[i])
+    {
+      int firstIndex = 0;
+      for (int j = i + 1; j < N; ++j)
+      {
+        if (a[j] == b[i])
+        {
+          firstIndex = j;
+          break;
+        }
+      }
+      swaps.push_back(pair<int, int>(i + 1, firstIndex + 1));
+      swap(a[i], a[firstIndex]);
+    }
+  }
+
+  printf("%d\n", swaps.size());
+  for (int i = 0; i < swaps.size(); ++i)
+    printf("%d %d\n", swaps[i].first, swaps[i].second);
+}
+
+int main()
+{
+  togetherForever();
+  return 0;
+}

Contests/DMOJ Contests/OTHS Coding Competition 3 (CCC)/S3

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link:
+  Points:
+******************************************/
+
+void domainExpansion()
+{
+  int N, K;
+  scanf("%d %d", &N, &K);
+
+  // .first = sorcerer index
+  // .second = strength
+  vector<pair<int, int>> regions(K, pair<int, int>({-1, -1}));
+  for (int i = 0; i < N; ++i)
+  {
+    int l, r, s;
+    scanf("%d %d %d", &l, &r, &s);
+    for (int j = l - 1; j < r; ++j)
+      // the current strength is greater
+      if (s > regions[j].second)
+        regions[j] = pair<int, int>({i, s});
+  }
+
+  vector<int> expansions(N, 0);
+  for (int i = 0; i < regions.size(); ++i)
+    if (regions[i].first != -1)
+      ++expansions[regions[i].first];
+
+  for (int i = 0; i < expansions.size(); ++i)
+    printf("%d ", expansions[i]);
+  printf("\n");
+}
+
+int main()
+{
+  domainExpansion();
+  return 0;
+}

Contests/DMOJ Contests/OTHS Coding Competition 3 (CCC)/S3.cpp

@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/******************************************
+  Link: https://leetcode.com/problems/word-break/description/
+  Runtime: 100.00%
+  Memory: 82.41%
+  Inspiration: https://www.youtube.com/watch?v=Sx9NNgInc3A
+******************************************/
+
+bool wordBreak(string s, vector<string> &wordDict)
+{
+  vector<int> dp(s.size() + 1, false);
+  dp[s.size()] = true;
+
+  for (int i = s.size() - 1; i >= 0; --i)
+  {
+    for (int j = 0; j < wordDict.size(); ++j)
+    {
+      if (i + wordDict[j].size() <= s.size())
+      {
+        string subStr = s.substr(i, wordDict[j].size());
+        if (subStr == wordDict[j])
+          dp[i] = dp[i + wordDict[j].size()];
+      }
+      if (dp[i])
+        break;
+    }
+  }
+
+  return dp[0];
+}
+
+int main()
+{
+  vector<string> dict({"apple", "pen"});
+  string s = "applepenapple";
+  cout << wordBreak(s, dict) << endl;
+  return 0;
+}

Solutions/Leetcode Solutions/medium/uniquePaths2.cpp

@@ -2,11 +2,61 @@
 
 using namespace std;
 
+void gates()
+{
+  int numberOfGates;
+  int numberOfPlanes;
+
+  scanf("%d", &numberOfGates);
+  scanf("%d", &numberOfPlanes);
+
+  vector<int> planes(numberOfPlanes);
+  set<int, greater<int>> gates;
+  for (int i = 0; i < numberOfPlanes; ++i)
+    scanf("%d", &planes[i]);
+  for (int i = 1; i <= numberOfGates; ++i)
+    gates.insert(i);
+
+  int numberOfPlanesAbleToDock = 0;
+  for (int i = 0; i < numberOfPlanes; ++i)
+  {
+    auto gate = gates.lower_bound(planes[i]);
+    if (gate == gates.end())
+      break;
+    gates.erase(*gate);
+    ++numberOfPlanesAbleToDock;
+  }
+
+  printf("%d\n", numberOfPlanesAbleToDock);
+}
+
+int subarraySumEqualsK(vector<int> &nums, int k)
+{
+  unordered_map<int, int> previousSums;
+  previousSums[0] = 1;
+  int prefixSum;
+  int numberOfSubarrays = 0;
+
+  for (int i = 0; i < nums.size(); ++i)
+  {
+    prefixSum += nums[i];
+    int diff = prefixSum - k;
+
+    if (previousSums.count(diff))
+      numberOfSubarrays += previousSums[diff];
+    if (previousSums.count(prefixSum))
+      ++previousSums[prefixSum];
+    else
+      previousSums[prefixSum] = 1;
+  }
+
+  return numberOfSubarrays;
+}
+
 int deleteAndEarn(vector<int> &nums)
 {
   sort(nums.begin(), nums.end());
   vector<int> numsPrime;
-
   unordered_map<int, int> counts;
 
   for (int i = 0; i < nums.size(); ++i)
@@ -20,45 +70,21 @@ int deleteAndEarn(vector<int> &nums)
   for (int i = 0; i < numsPrime.size(); ++i)
   {
     int value = numsPrime[i] * counts[numsPrime[i]];
-    if (i > 0 && numsPrime[i] - numsPrime[i - 1] == 1)
-      dp[i] = max(dp[i - 1], value + (i >= 2 ? dp[i - 2] : 0));
-    else if (i > 0)
-      dp[i] = value + dp[i - 1];
+
+    if (i > 0 && numsPrime[i] - numsPrime[i - 1] > 1)
+      value += numsPrime[i - 1];
+    else if (i >= 2 && numsPrime[i] - numsPrime[i - 1] == 1)
+      value += dp[i - 2];
+    if (i > 0)
+      dp[i] = max(dp[i - 1], value);
     else
       dp[i] = value;
   }
 
   return dp[dp.size() - 1];
 }
 
-int subarraySumEqualsK(vector<int> &nums, int k)
-{
-  unordered_map<int, int> prefixSumsCount;
-  prefixSumsCount[0] = 1;
-
-  int prefixSum = 0;
-  int diff = 0;
-  int numberOfSubarrays = 0;
-
-  for (int i = 0; i < nums.size(); ++i)
-  {
-    prefixSum += nums[i];
-    diff = prefixSum - k;
-
-    if (prefixSumsCount.count(diff))
-      numberOfSubarrays += prefixSumsCount[diff];
-    if (prefixSumsCount.count(prefixSum))
-      ++prefixSumsCount[prefixSum];
-    else
-      prefixSumsCount[prefixSum] = 1;
-  }
-
-  return numberOfSubarrays;
-}
-
 int main()
 {
-  vector<int> nums({2, 2, 3, 3, 3, 4});
-  cout << deleteAndEarn(nums) << endl;
   return 0;
 }