68-9kyo-hwang

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,125 @@
+#include <string>
+#include <vector>
+#include <functional>
+#include <set>
+
+using namespace std;
+using FPoint = pair<int, int>;
+
+vector<vector<FPoint>> GetBlocksFrom(vector<vector<int>>& Board, bool IsBoard = true)
+{
+    const vector<FPoint> Offset{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
+    auto OutOfBound = [&](int x, int y)
+    {
+        return x < 0 || x >= Board.size() || y < 0 || y >= Board.size();
+    };
+
+    vector<vector<FPoint>> Blocks;
+
+    function<void(int, int)> DFS = [&](int x, int y)
+    {
+        Blocks.back().emplace_back(x, y);
+        Board[x][y] = (IsBoard ? 1 : 0);
+
+        for(const auto& [dx, dy] : Offset)
+        {
+            int nx = x + dx, ny = y + dy;
+            if(!OutOfBound(nx, ny) && Board[nx][ny] == (IsBoard ? 0 : 1))
+            {
+                DFS(nx, ny);
+            }
+        }
+    };
+
+    for(int i = 0; i < Board.size(); ++i)
+    {
+        for(int j = 0; j < Board.size(); ++j)
+        {
+            if(IsBoard && Board[i][j] == 0
+              || !IsBoard && Board[i][j] == 1)
+            {
+                Blocks.push_back({});
+                DFS(i, j);
+            }
+        }
+    }
+
+    return Blocks;
+}
+
+vector<vector<int>> GetGridFrom(const vector<FPoint>& Block)
+{
+    auto [MinX, MinY] = Block[0];
+    auto [MaxX, MaxY] = Block[0];
+
+    for(const auto& [x, y] : Block)
+    {
+        if(x < MinX) MinX = x;
+        else if(x > MaxX) MaxX = x;
+
+        if(y < MinY) MinY = y;
+        else if(y > MaxY) MaxY = y;
+    }
+
+    vector<vector<int>> Grid(MaxX - MinX + 1, vector<int>(MaxY - MinY + 1, 0));
+    for(const auto& [x, y] : Block)
+    {
+        Grid[x - MinX][y - MinY] = 1;
+    }
+
+    return Grid;
+}
+
+int Rotate(vector<vector<int>>& Grid)
+{
+    vector<vector<int>> Rotated(Grid[0].size(), vector<int>(Grid.size(), 0));
+    int NumCell = 0;
+
+    for(int i = 0; i < Grid.size(); ++i)
+    {
+        for(int j = 0; j < Grid[0].size(); ++j)
+        {
+            if(Grid[i][j] == 1) NumCell++;
+            Rotated[j][Grid.size() - 1 - i] = Grid[i][j];
+        }
+    }
+
+    Grid = Rotated;
+    return NumCell;
+}
+
+int solution(vector<vector<int>> InGameBoard, vector<vector<int>> InTable) 
+{
+    vector<vector<FPoint>> BoardBlocks = GetBlocksFrom(InGameBoard, true);
+    vector<vector<FPoint>> TableBlocks = GetBlocksFrom(InTable, false);
+
+    set<vector<FPoint>> UsedTableBlocks;
+    int Answer = 0;
+
+    for(const vector<FPoint>& BoardBlock : BoardBlocks)
+    {
+        bool IsFilled = false;
+        vector<vector<int>> BoardBlockGrid = GetGridFrom(BoardBlock);
+
+        for(const vector<FPoint>& TableBlock : TableBlocks)
+        {
+            if(IsFilled) break;
+            if(UsedTableBlocks.count(TableBlock)) continue;
+
+            vector<vector<int>> TableBlockGrid = GetGridFrom(TableBlock);
+            for(int i = 0; i < 4; ++i)
+            {
+                int NumCell = Rotate(TableBlockGrid);
+                if(BoardBlockGrid == TableBlockGrid)
+                {
+                    Answer += NumCell;
+                    UsedTableBlocks.emplace(TableBlock);
+                    IsFilled = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    return Answer;
+}

9-kyo-hwang/Greedy/2024 KAKAO WINTER INTERNSHIP n + 1 카드게임.cpp

@@ -0,0 +1,77 @@
+#include <string>
+#include <vector>
+#include <set>
+#include <algorithm>
+
+using namespace std;
+
+struct Comparator
+{
+    bool operator()(const pair<int, int>& Lhs, const pair<int, int>& Rhs) const
+    {
+        const auto& [LhsCard, LhsCoin] = Lhs;
+        const auto& [RhsCard, RhsCoin] = Rhs;
+
+        return LhsCoin == RhsCoin ? LhsCard < RhsCard : LhsCoin < RhsCoin;
+    }
+};
+
+int solution(int InCoin, vector<int> InCards) 
+{
+    const int N = (int)InCards.size();
+    const int RequiredSum = N + 1;
+    reverse(InCards.begin(), InCards.end());
+
+    set<pair<int, int>, Comparator> Deck;
+    for(int i = 0; i < N / 3; ++i)
+    {
+        Deck.emplace(InCards.back(), 0); InCards.pop_back();
+    }
+
+    int Round;
+    for(Round = 1; !InCards.empty(); ++Round)
+    {
+        Deck.emplace(InCards.back(), 1); InCards.pop_back();
+        Deck.emplace(InCards.back(), 1); InCards.pop_back();
+
+        bool FindCombination = false;
+        for(const auto& [Card, Coin] : Deck)
+        {
+            int TargetCard = RequiredSum - Card;
+            if(Card == TargetCard)
+            {
+                continue;
+            }
+
+            int TargetCoin;
+            if(Deck.count({TargetCard, 0}))
+            {
+                TargetCoin = 0;
+            }
+            else if(Deck.count({TargetCard, 1}))
+            {
+                TargetCoin = 1;
+            }
+            else
+            {
+                continue;
+            }
+
+            if(Coin + TargetCoin <= InCoin)
+            {
+                InCoin -= (Coin + TargetCoin);
+                Deck.erase({Card, Coin});
+                Deck.erase({TargetCard, TargetCoin});
+                FindCombination = true;
+                break;
+            }
+        }
+
+        if(false == FindCombination)
+        {
+            break;
+        }
+    }
+
+    return Round;
+}

9-kyo-hwang/Greedy/디펜스 게임.cpp

@@ -0,0 +1,33 @@
+#include <string>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+int solution(int N, int K, vector<int> InEnemies) 
+{
+    priority_queue<int> NumofEnemiesBlocked;
+    int Round = 0;
+
+    for(int Enemy : InEnemies)
+    {
+        N -= Enemy;
+        NumofEnemiesBlocked.emplace(Enemy);
+
+        if(N < 0)
+        {
+            if(K == 0)
+            {
+                break;
+            }
+
+            N += NumofEnemiesBlocked.top();
+            NumofEnemiesBlocked.pop();
+            K--;
+        }
+
+        Round++;
+    }
+
+    return Round;
+}

9-kyo-hwang/README.md

@@ -63,4 +63,9 @@
 | 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) |
+| 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) |
+| 65차시 | 2024.9.11  | Greedy                     | [디펜스 게임](https://school.programmers.co.kr/learn/courses/30/lessons/142085)   | [#224](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/224) |
+| 66차시 | 2024.9.14  | Sliding Window             | [할인 행사](https://school.programmers.co.kr/learn/courses/30/lessons/131127)   | [#225](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/225) |
+| 67차시 | 2024.9.23  | Graph Traversal            | [퍼즐 조각 채우기](https://school.programmers.co.kr/learn/courses/30/lessons/84021)   | [#228](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/228) |
+| 68차시 | 2024.10.1  | Greedy                     | [2024 KAKAO WINTER INTERNSHIP n + 1 카드 게임](https://school.programmers.co.kr/learn/courses/30/lessons/258707)   | [#230](https://github.com/AlgoLeadMe/AlgoLeadMe-3/pull/230) |

9-kyo-hwang/Sliding Window/할인 행사.cpp

@@ -0,0 +1,35 @@
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+using namespace std;
+
+int solution(vector<string> InWants, vector<int> InNumbers, vector<string> InDiscounts) 
+{
+    unordered_map<string, int> NumberbyWants;
+    for(int i = 0; i < 9; ++i)
+    {
+        NumberbyWants[InDiscounts[i]]++;
+    }
+
+    int Answer = 0;
+    for(int i = 9; i < InDiscounts.size(); ++i)
+    {
+        NumberbyWants[InDiscounts[i]]++;
+        bool Flag = true;
+
+        for(int j = 0; j < InWants.size(); ++j)
+        {
+            if(NumberbyWants[InWants[j]] != InNumbers[j])
+            {
+                Flag = false;
+                break;
+            }
+        }
+
+        Answer += Flag;
+        NumberbyWants[InDiscounts[i - 9]]--;
+    }
+
+    return Answer;
+}