64-9kyo-hwang

9-kyo-hwang/Binary Search/13397 구간 나누기 2.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int main()
+{
+    cin.tie(nullptr)->sync_with_stdio(false);
+
+    int N, M; cin >> N >> M;
+
+    vector<int> Nums(N);
+    for(int& Num : Nums)
+    {
+        cin >> Num;
+    }
+
+    auto IsValid = [&](int EstimateScore)
+    {
+        int Count = 1;
+        int Min = Nums[0], Max = Nums[0];
+
+        for(int i = 1; i < N; ++i)
+        {
+            Min = min(Min, Nums[i]);
+            Max = max(Max, Nums[i]);
+
+            if(Max - Min > EstimateScore)
+            {
+                Count++;
+                Min = Nums[i];
+                Max = Nums[i];
+            }
+        }
+
+        return Count <= M;
+    };
+
+    int Min = 0, Max = *max_element(Nums.begin(), Nums.end());
+    int Score = Max;
+    while(Min <= Max)
+    {
+        int EstimateScore = (Min + Max) / 2;
+        if(IsValid(EstimateScore))
+        {
+            Score = min(Score, EstimateScore);
+            Max = EstimateScore - 1;
+        }
+        else
+        {
+            Min = EstimateScore + 1;
+        }
+    }
+
+    cout << Score;
+
+    return 0;
+}

9-kyo-hwang/Binary Search/징검다리.cpp

@@ -0,0 +1,49 @@
+#include <string>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int solution(int InDistance, vector<int> InRocks, int NumRemove) 
+{
+    InRocks.emplace_back(InDistance);
+    sort(InRocks.begin(), InRocks.end());
+
+    int LowerDistance = 1, UpperDistance = InDistance;
+    int Answer = 0;
+
+    auto IsValid = [&](int EstimateDistance)
+    {
+        int Count = 0, CurrentPos = 0;
+        for(int RockPos : InRocks)
+        {
+            int Distance = RockPos - CurrentPos;
+            if(Distance >= EstimateDistance)
+            {
+                CurrentPos = RockPos;
+            }
+            else
+            {
+                Count++;
+            }
+        }
+
+        return Count <= NumRemove;
+    };
+
+    while(LowerDistance <= UpperDistance)
+    {
+        int EstimateDistance = (LowerDistance + UpperDistance) / 2;
+        if(IsValid(EstimateDistance))
+        {
+            Answer = EstimateDistance;
+            LowerDistance = EstimateDistance + 1;
+        }
+        else
+        {
+            UpperDistance = EstimateDistance - 1;
+        }
+    }
+
+    return Answer;
+}

9-kyo-hwang/Graph Traversal/무인도 여행.cpp

@@ -0,0 +1,45 @@
+#include <string>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int Merge(vector<string>& Maps, int x, int y)
+{
+    if(x < 0 || x >= Maps.size() || y < 0 || y >= Maps[0].size() || Maps[x][y] == 'X') 
+    {
+        return 0;
+    }
+
+    int Day = Maps[x][y] - '0';
+    Maps[x][y] = 'X';
+
+    return Day 
+        + Merge(Maps, x - 1, y) 
+        + Merge(Maps, x, y + 1) 
+        + Merge(Maps, x + 1, y) 
+        + Merge(Maps, x, y - 1);
+}
+
+vector<int> solution(vector<string> Maps) 
+{
+    vector<int> DaysofStay;
+    for(int i = 0; i < Maps.size(); ++i)
+    {
+        for(int j = 0; j < Maps[0].size(); ++j)
+        {
+            if(Maps[i][j] != 'X')
+            {
+                DaysofStay.emplace_back(Merge(Maps, i, j));
+            }
+        }
+    }
+
+    if(DaysofStay.empty()) 
+    {
+        return {-1};
+    }
+
+    sort(DaysofStay.begin(), DaysofStay.end());
+    return DaysofStay;
+}

9-kyo-hwang/Greedy/마법의 엘리베이터.cpp

@@ -0,0 +1,38 @@
+#include <vector>
+#include <string>
+
+using namespace std;
+
+int solution(int Storey) 
+{
+    int Answer = 0;
+
+    while(Storey)
+    {
+        int Remainder = Storey % 10;
+        int Quotient = Storey / 10;
+
+        if(Remainder < 5)  // 예: 54
+        {
+            Answer += Remainder;  // 54 -> 50
+        }
+        else if(Remainder > 5)  // 예: 16
+        {
+            ++Quotient;
+            Answer += 10 - Remainder;  // 16 -> 20
+        }
+        else
+        {
+            if(Quotient % 10 >= 5)  // 예: 55 -> 60 / 25 -> 20
+            {
+                ++Quotient;  
+            }
+
+            Answer += Remainder;
+        }
+
+        Storey = Quotient;
+    }
+
+    return Answer;
+}

9-kyo-hwang/Implementation/과제 진행하기.cpp

@@ -0,0 +1,79 @@
+#include <string>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+struct FPlan
+{
+    string Name;
+    int Start;
+    int Playtime;
+
+    FPlan() {}
+    FPlan(const string& InName, const string& InStart, const string& InPlaytime)
+    {
+        Name = InName;
+        Start = stoi(InStart.substr(0, 2)) * 60 + stoi(InStart.substr(3, 2));
+        Playtime = stoi(InPlaytime);
+    }
+
+    const bool operator<(const FPlan& Rhs) const
+    {
+        return Start < Rhs.Start;
+    }
+};
+
+vector<string> solution(vector<vector<string>> InPlans) 
+{
+    vector<FPlan> Plans;
+    for(const vector<string>& Plan : InPlans)
+    {
+        Plans.push_back({Plan[0], Plan[1], Plan[2]});
+    }
+
+    sort(Plans.begin(), Plans.end());
+
+    vector<string> Result;
+    vector<int> Paused;
+
+    for(int i = 0; i < Plans.size() - 1; ++i)
+    {
+        int TimeDifference = Plans[i + 1].Start - Plans[i].Start;
+        if(Plans[i].Playtime > TimeDifference)
+        {
+            Plans[i].Playtime -= TimeDifference;
+            Paused.emplace_back(i);
+            continue;
+        }
+
+        TimeDifference -= Plans[i].Playtime;
+        Plans[i].Playtime = 0;
+        Result.emplace_back(Plans[i].Name);
+
+        while(TimeDifference > 0 && !Paused.empty())
+        {
+            int Index = Paused.back();
+            if(Plans[Index].Playtime > TimeDifference)
+            {
+                Plans[Index].Playtime -= TimeDifference;
+                break;
+            }
+
+            TimeDifference -= Plans[Index].Playtime;
+            Plans[Index].Playtime = 0;
+            Result.emplace_back(Plans[Index].Name);
+            Paused.pop_back();
+        }
+    }
+
+    Result.emplace_back(Plans.back().Name);
+
+    while(!Paused.empty())
+    {
+        Result.emplace_back(Plans[Paused.back()].Name);
+        Paused.pop_back();
+    }
+
+    return Result;
+}

9-kyo-hwang/Implementation/테이블 해시 함수.cpp

@@ -0,0 +1,26 @@
+#include <string>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int solution(vector<vector<int>> Data, int Col, int RowBegin, int RowEnd) 
+{
+    sort(Data.begin(), Data.end(), [&](const auto& Lhs, const auto& Rhs)
+         {
+             return Lhs[Col - 1] == Rhs[Col - 1] ? Lhs[0] > Rhs[0] : Lhs[Col - 1] < Rhs[Col - 1];
+         });
+
+    int HashVal = 0;
+    for(int i = RowBegin; i <= RowEnd; ++i)
+    {
+        int S_i = 0;
+        for(const int Val : Data[i - 1])
+        {
+            S_i += Val % i;
+        }
+        HashVal ^= S_i;
+    }
+
+    return HashVal;
+}

9-kyo-hwang/README.md

@@ -57,4 +57,11 @@
 | 54차시 | 2024.7.04  | Data Structure             | [16934 게임 닉네임](https://www.acmicpc.net/problem/16934)   | [#197](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/197) |
 | 55차시 | 2024.7.09  | Simulation                 | [17144 미세먼지 안녕!](https://www.acmicpc.net/problem/16934)   | [#202](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/202) |
 | 56차시 | 2024.7.12  | Tree                       | [15681 트리와 쿼리](https://www.acmicpc.net/problem/15681)   | [#204](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/204) |
-| 57차시 | 2024.7.15  | Dynamic Programming        | [17070 파이프 옮기기 1](https://www.acmicpc.net/problem/17070)   | [#206](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/206) |
+| 57차시 | 2024.7.15  | Dynamic Programming        | [17070 파이프 옮기기 1](https://www.acmicpc.net/problem/17070)   | [#206](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/206) |
+| 58차시 | 2024.7.29  | Trie                       | [14725 개미굴](https://www.acmicpc.net/problem/14725)   | [#207](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/207) |
+| 59차시 | 2024.8.01  | Greedy                     | [마법의 엘리베이터](https://school.programmers.co.kr/learn/courses/30/lessons/148653)   | [#210](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/210) |
+| 60차시 | 2024.8.05  | Implementation             | [과제 진행하기](https://school.programmers.co.kr/learn/courses/30/lessons/176962)   | [#213](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/213) |
+| 61차시 | 2024.8.08  | Implementation             | [테이블 해시 함수](https://school.programmers.co.kr/learn/courses/30/lessons/147354)   | [#214](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/214) |
+| 62차시 | 2024.8.12  | Graph Traversal            | [무인도 여행](https://school.programmers.co.kr/learn/courses/30/lessons/154540)   | [#217](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/217) |
+| 63차시 | 2024.9.3   | Binary Search              | [구간 나누기2](https://www.acmicpc.net/problem/13397)   | [#218](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/218) |
+| 64차시 | 2024.9.8   | Binary Search              | [징검다리](https://school.programmers.co.kr/learn/courses/30/lessons/43236)   | [#221](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/221) |

9-kyo-hwang/Trie/14725 개미굴.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <string>
+#include <map>
+
+using namespace std;
+
+struct FNode
+{
+    map<string, FNode*> Node;
+};
+
+FNode* Root;
+
+void Print(FNode* InNode = Root, const string& Prefix="")
+{
+    if(InNode == nullptr)
+    {
+        return;
+    }
+
+    for(const auto& [Data, Next] : InNode->Node)
+    {
+        cout << Prefix << Data << "\n";
+        Print(Next, Prefix + "--");
+    }
+}
+
+int main()
+{
+    cin.tie(nullptr)->sync_with_stdio(false);
+
+    Root = new FNode();
+
+    int N; cin >> N;
+    for(int n = 0; n < N; ++n)
+    {
+        FNode* Ptr = Root;
+
+        int K; cin >> K;
+        for(int k = 0; k < K; ++k)
+        {
+            string Info; cin >> Info;
+            if(Ptr->Node.count(Info) == 0)
+            {
+                Ptr->Node[Info] = new FNode();
+            }
+
+            Ptr = Ptr->Node[Info];
+        }
+    }
+
+    Print();
+
+    return 0;
+}