Apes Together Strong.

[1-DP][Medium] 213. House Robber II

자전거통학 — Thu, 8 Aug 2024 10:54:42 +0900

https://leetcode.com/problems/house-robber-ii/description/

주어진 정수 배열을 각 집과 그 집에서 rob 할수 있는 value라고 한다.

이때 도둑은 인접해 있는 집은 털수가 없다. 또한 집들이 원형으로 연결되어 있다고 가정한다.

따라서 마지막 집과 첫 집은 연결되어 있다.

도둑이 훔칠 수 있는 최대값을 찾아라.

House Robber I 문제의 변형이다.

특정 위치에서 idx+2 혹은 idx+3에 접근 할 수 있다.

다만, 0에서 시작했으면 size()-1 까지만 접근 가능하다.

따라서 캐시 버퍼를 만들때 이 경우를 고려한다. 따라서 size() x 2의 캐시 사이즈가 필요하다.

또한 시작 시, 첫 집에서 시작 할 수 있고, 이때는 마지막 집은 접근 할 수 없다.

두번째, 혹은 세번째 집에서 시작 할 수 있고 이때는 마지막 집은 접근 가능하다.

이를 기본으로 로직을 만든다.

코드

int doRobDP(int idx, vector<int>& vCache, const vector<int>& nums, int n)
{
    if(idx >= n)
        return 0;

    int idxCache = n==nums.size()-1 ? idx : nums.size() + idx;
    if(vCache[idxCache] >= 0)
        return vCache[idxCache];

    vCache[idxCache] = nums[idx] + max(doRobDP(idx+2, vCache, nums, n), doRobDP(idx+3, vCache, nums, n));
    return vCache[idxCache];
}

int rob(vector<int>& nums) 
{
    if(nums.size()==1)
        return nums[0];

    vector<int> vCache;
    vCache.resize(nums.size()*2, -1);

    int cost = max(doRobDP(0, vCache, nums, nums.size()-1), doRobDP(1, vCache, nums, nums.size()));
    cost = max(cost, doRobDP(2, vCache, nums, nums.size()));
    return cost;
}

결과

[1D DP][Medium] 198. House Robber

자전거통학 — Mon, 5 Aug 2024 21:04:56 +0900

https://leetcode.com/problems/house-robber/description/

정수 배열이 주어지고 이것은 각 집과 훔칠 수 있는 돈을 의미한다.

도둑은 인접한 집은 방문할 수 없다.

모든 집을 털었을 때, 기대할 수 있는 최대 값을 찾아라.

아래 문제에 비유적 설명을 덧댄 문제.

https://leetcode.com/problems/min-cost-climbing-stairs/description/

인접해서 방문 할 수 없으므로,

특정 위치에서 기대 할수 있는 최대 값은

nums[idx] + max(idx+1 이동, idx+2 이동)

일 것이다.

코드

 int minCostDP(vector<int>& vCache, int idx, vector<int>& cost)
{
    if(idx >= cost.size())
        return 0;

    if(vCache[idx] >= 0)
        return vCache[idx];

    vCache[idx] = cost[idx] + min(minCostDP(vCache, idx+1, cost), minCostDP(vCache, idx+2, cost));
    return vCache[idx];
}

int minCostClimbingStairs(vector<int>& cost) 
{
    vector<int> vCache;
    vCache.resize(cost.size(), -1);
    return min(minCostDP(vCache, 0, cost), minCostDP(vCache, 1, cost));
}

결과

[1D DP][Easy] 746. Min Cost Climbing Stairs

자전거통학 — Mon, 5 Aug 2024 20:53:01 +0900

https://leetcode.com/problems/min-cost-climbing-stairs/description/

정수배열 cost는 각 계단을 밟는 비용을 의미한다.

한번에 계단은 하나 혹은 두개씩 밟을 수 있다.

시작은 0이나 1 위치에서 시작 할 수 있다.

이때, 최고 높은 계단에 도달하기 위한 최소 비용을 구하라.

특정 위치에서 비용은

cost[idx] + min(1단계, 2단계)

일 것이다.

위를 기준으로 코드를 만든다.

코드

int minCostDP(vector<int>& vCache, int idx, vector<int>& cost)
{
    if(idx >= cost.size())
        return 0;

    if(vCache[idx] >= 0)
        return vCache[idx];

    vCache[idx] = cost[idx] + min(minCostDP(vCache, idx+1, cost), minCostDP(vCache, idx+2, cost));
    return vCache[idx];
}


int minCostClimbingStairs(vector<int>& cost) 
{
    vector<int> vCache;
    vCache.resize(cost.size(), -1);
    return min(minCostDP(vCache, 0, cost), minCostDP(vCache, 1, cost));
}

결과

[1D DP][Easy] 70. Climbing Stairs

자전거통학 — Sat, 3 Aug 2024 23:16:36 +0900

https://leetcode.com/problems/climbing-stairs/description/

한번에 1개 혹은 2개의 계단을 밟을 수 있다고 할 때, 계단을 다 오를 모든 경우의 수를 찾아라.

리마인드 하듯이 문제를 풀어 본다.

DP 문제는 복합적인 듯한 문제를 단일 단계로 해석하는 것이 중요하다.

한 단계에서 1개 혹은 2개만 올라 갈 수 있다.

또한 끝까지 오르면 그만 둔다.

따라서 특정 단계에서 오른 횟수를 구한다면, 그 값을 재활용 할 수 있다.

(마지막 계단 바로 앞에서는 1회 두 번, 2회 한번의 두 가지 경우가 존재하고, 이것은 이 전에 무엇을 했던 동일하다.)

코드

int climb(vector<int>& vCache, int idx, int n)
{
    if(idx >= n)
        return 1;

    if(vCache[idx] >= 0)
        return vCache[idx];

    int ret = climb(vCache, idx + 1, n);
    ret += climb(vCache, idx + 2, n);
    vCache[idx] = ret;
    return ret;
}

int climbStairs(int n) 
{
    vector<int> vCache;
    vCache.resize(n, -1);
    return climb(vCache, 1, n);
}

결과

[BackTrack][Hard] 51. N-Queens

자전거통학 — Wed, 31 Jul 2024 23:55:51 +0900

https://leetcode.com/problems/n-queens/description/

아래와 같은 N-Queens 를 만든다고 할때, n 이 주어지면 이에 가능한 N-Queens를 모두 찾아라.

문제 자체는 쉽다.

매 칸당 Queen을 놓을 수 있다면, 놓거나 아니면 놓지 않는다.

코드

bool CanPlace(int idx, const vector<string>& vCur, int n)
{
    int y = idx / n;
    int x = idx % n;

    // check H
    for(int h = 0; h < n; ++h)
    {
        if(h!=x && vCur[y][h]=='Q')
            return false;
    }

    // check V
    for(int v = 0; v < n; ++v)
    {
        if(v!=y && vCur[v][x]=='Q')
            return false;
    }

    // check to RT
    int xx = x+1;
    int yy = y-1;
    while(xx<n && yy>=0)
    {
        if(vCur[yy--][xx++] == 'Q')
            return false;
    }

    // check to LB
    xx = x-1;
    yy = y+1;
    while(xx>=0 && yy<n)
    {
        if(vCur[yy++][xx--] == 'Q')
            return false;
    }

    // check to RB
    xx = x+1;
    yy = y+1;
    while(xx<n && yy<n)
    {
        if(vCur[yy++][xx++] == 'Q')
            return false;
    }

    // check to LT
    xx = x-1;
    yy = y-1;
    while(xx>=0 && yy>=0)
    {
        if(vCur[yy--][xx--] == 'Q')
            return false;
    }

    return true;
}

void solveNQueensBT(int idx, vector<vector<string>>& vRet, vector<string>& vCur, int n)
{
    if(idx >= n*n)
    {
        int cnt = 0;
        for(int q = 0; q < n*n; ++q)
        {
            if(vCur[q/n][q%n]=='Q')
                ++cnt;
        }
        // cout << cnt << endl;
        if(cnt == n)
            vRet.push_back(vCur);
        return;
    }

    // Put 'Q' on the position if possible.
    if(CanPlace(idx, vCur, n))
    {
        int yy = idx / n;
        int xx = idx % n;

        vCur[yy][xx] = 'Q';
        solveNQueensBT(idx+1, vRet, vCur, n);
        vCur[yy][xx] = '.';
    }

    // Skip putting 'Q'.
    solveNQueensBT(idx+1, vRet, vCur, n);
}

vector<vector<string>> solveNQueens(int n) 
{
    vector<vector<string>> vRet;
    vector<string> vCur;
    for(int y = 0; y < n; ++y)
    {
        string line = "";
        for(int x = 0; x < n; ++x)
            line += ".";
        vCur.push_back(line);
    }
    solveNQueensBT(0, vRet, vCur, n);

    return vRet;    
}

결과

이 방법은 답은 찾아 지지만, 느리다.

더 최적화 해 보자.

N-Queens 조건 상, 하나의 x 축에 두개의 값이 올 수 없다.

그렇다면, x 축에 놓는 값을 하나씩 이동하면서 확인 할 수 있다.

이 x 축으로 놓는 방식을 y 만큼 한다. (문제에서 모두 n)

void NQueens_BT(vector<vector<string>>& vRet, string& strCur, int n, int ix, int iy)
{
    if (iy >= n)
    {
        vector<string> vBuff;
        for (int q = 0; q < n; ++q)
        {
            string strTemp = strCur;
            strTemp = strTemp.substr(n * q, n);
            vBuff.push_back(strTemp);
        }
        vRet.push_back(vBuff);
        return;
    }

    for(int x = 0 ; x < n; ++x)
    {
        int curIdx = iy*n + x;
        if (IsValid_NQueens(strCur, n, x, iy))
        {
            strCur[curIdx] = 'Q';
            NQueens_BT(vRet, strCur, n, ix, iy+1);
            strCur[curIdx] = '.';
        }
    }
}

하나의 행에 하나의 Queen을 놓으면 다음 행으로 넘어가면 된다.

결과

훨씬 근접한 결과를 얻었다.

[BackTrack][Medium] 17. Letter Combinations of a Phone Number

자전거통학 — Tue, 30 Jul 2024 22:03:55 +0900

https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/

2-9 까지의 다이얼을 누른다고 할 때, 매칭 가든한 모든 문자열을 찾아라.

BackTracking의 고전과도 같은 문제.

depth가 더해 지면서 진행 하는 index 는 찾고자 하는 input digit이다.

이 데이터를 가지고 가질 수 있는 문자를 문자열의 길이가 digits만큼 되면 반환 buff에 넣는다.

코드

void letterCombinationsBT(const string& digits, map<char, vector<char>>& buff, vector<string>& vOut, string& cur)
{
    if (cur.size() >= digits.size())
    {
        if(cur.size() > 0)
            vOut.push_back(cur);
        return;
    }

    char num = digits[cur.size()];
    auto vChar = buff[num];
    for (int q = 0; q < vChar.size(); ++q)
    {
        cur.push_back(vChar[q]);
        letterCombinationsBT(digits, buff, vOut, cur);
        cur.pop_back();
    }
}

vector<string> letterCombinations(string digits) 
{
    map<char, vector<char>> buff;
    buff['2'] = { 'a', 'b', 'c' };
    buff['3'] = { 'd', 'e', 'f' };
    buff['4'] = { 'g', 'h', 'i' };
    buff['5'] = { 'j', 'k', 'l' };
    buff['6'] = { 'm', 'n', 'o' };
    buff['7'] = { 'p', 'q', 'r', 's'};
    buff['8'] = { 't', 'u', 'v' };
    buff['9'] = { 'w', 'x', 'y', 'z'};

    vector<string> vOut;
    string cur;
    letterCombinationsBT(digits, buff, vOut, cur);
    return vOut;
}

결과

[BackTrack][Medium] 131. Palindrome Partitioning

자전거통학 — Mon, 29 Jul 2024 22:47:08 +0900

https://leetcode.com/problems/palindrome-partitioning/description/

문자열이 주어질 때, palindrome한 sub string의 모음을 찾아라.

BackTrack의 원리 자체는 같지만, 구성과 진행 조건이 조금 다르다.

실제로 string을 cut 해 보며 이것이 palindrome인지 확인하고, 그럴 때만 진행해 나간다.

나머지 조건은 대동소이 하다.

코드

 bool IsPalindrome(const string& s)
{
    if (s.size() <= 1)
        return true;
    int mid = s.size() / 2;
    for (int q = 0; q < mid; ++q)
    {
        if (s[q] != s[s.size() - q - 1])
            return false;
    }
    return true;
}
void partitionBT(vector<vector<string>>& vRet, vector<string>& vCur, const string& s, int idx)
{
    if (idx >= s.size())
    {
        vRet.push_back(vCur);
        return;
    }

    for (int q = idx; q < s.size(); ++q)
    {
        string cur = s.substr(idx, q-idx+1);
        if (IsPalindrome(cur))
        {
            // cout << cur << endl;
            vCur.push_back(cur);
            partitionBT(vRet, vCur, s, q+1);
            vCur.pop_back();
        }
    }
}

vector<vector<string>> partition(string s) 
{
    vector<vector<string>> vRet;
    vector<string> vCur;
    partitionBT(vRet, vCur, s, 0);
    return vRet;
}

결과

[BackTrack][Medium] 79. Word Search

자전거통학 — Fri, 26 Jul 2024 01:15:11 +0900

https://leetcode.com/problems/word-search/description/

m x n grid의 문자열이 주어진다.

이 안에서 특정 word가 존재하는지 여부를 확인하라.

맞는 단어를 하나 하나 확인해 가며 진행한다.

다만 시작 지점이 모든 영역이다.

로직 자체는 간단하다.

코드

bool existBT(int idx, vector<bool>& vVisit, vector<vector<char>>& board, string word, int idxW)
{
    int H = board.size();
    int W = board[0].size();
    char target = word[idxW];
    int iy = idx / W;
    int ix = idx % W;
    char cur = board[iy][ix];
    if(vVisit[idx] || target!= cur)
        return false;

    vVisit[idx] = true;
    if(idxW+1 == word.size())
        return true;

    // left 
    if(ix > 0)
    {
        if(existBT(idx-1, vVisit, board, word, idxW+1))
            return true;
    }
    // right
    if(ix < W-1)
    {
        if(existBT(idx+1, vVisit, board, word, idxW+1))
            return true;
    }
    // up
    if(iy > 0)    
    {
        if(existBT(idx-W, vVisit, board, word, idxW+1))
            return true;
    }
    // down
    if(iy < H-1)  
    {   
        if(existBT(idx+W, vVisit, board, word, idxW+1))
            return true;
    }
    vVisit[idx] = false;
    return false;
}


bool exist(vector<vector<char>>& board, string word) 
{        
    vector<bool> vVisit;
    vVisit.resize(board.size()*board[0].size(), false);
    for(int q = 0; q < vVisit.size(); ++q)
    {
        if(existBT(q, vVisit, board, word, 0))
            return true;
    }
    return false;
}

결과

[BackTrack][Medium] 40. Combination Sum II

자전거통학 — Fri, 26 Jul 2024 00:10:24 +0900

https://leetcode.com/problems/combination-sum-ii/description/

주어진 정수 배열의 합이 target이 되는 조합을 찾아라.

이때 정수에는 중복값이 있을 수 있다.

결과에서 중복 결과를 제거하라.

Subset II와 거의 같은 풀이의 문제.

같은 로직으로 중복을 제거 할 수 있다.

코드

void combinationSum2BT(int idx, vector<vector<int>>& vRet, vector<int>& vCur, vector<int>& candidates, int target)
{
    if(target <= 0)
    {
        if(target == 0)
            vRet.push_back(vCur);
        return;
    }

    for(int q = idx; q < candidates.size(); ++q)
    {
        if(q>idx && candidates[q-1]==candidates[q])
            continue;

        vCur.push_back(candidates[q]);
        combinationSum2BT(q+1, vRet, vCur, candidates, target-candidates[q]);
        vCur.pop_back();
    }
}

vector<vector<int>> combinationSum2(vector<int>& candidates, int target) 
{
    sort(candidates.begin(), candidates.end());
    vector<vector<int>> vRet;
    vector<int> vCur;

    combinationSum2BT(0, vRet, vCur, candidates, target );
    return vRet;
}

결과

[ ][BackTrack][Medium] 90. Subsets II

자전거통학 — Tue, 23 Jul 2024 22:00:31 +0900

https://leetcode.com/problems/subsets-ii/description/

정수 배열이 주어 질 때, 가능한 한 모든 sub set을 찾아라.

이때 중복이 없도록 하라.

subset 1과 기본적으로 동일하지만, input에 중복값이 주어진다.

따라서 결과에서는 주어진 input을 제외하고 다른 중복이 있으면 안된다.

1, 2

2, 1 등은 허용하지 않는다.

1과 기본적으로 같은 흐름으로 하되,

결과에 중복만 set으로 filter 해 보았다.

코드

void subsetsWithDupBT(int idx, vector<vector<int>>& vRet, vector<int>& vCur, vector<int>& nums, unordered_set<string>& sBuff)
{
    string temp;
    for(int q = 0; q < vCur.size(); ++q)
        temp += (to_string(vCur[q]) + "_");

    if(sBuff.find(temp) == sBuff.end())
    {
        vRet.push_back(vCur);
        sBuff.insert(temp);
    }
    if (idx >= nums.size())
        return;

    for (int q = idx; q < nums.size(); ++q)
    {
        vCur.push_back(nums[q]);
        subsetsWithDupBT(q + 1, vRet, vCur, nums, sBuff);
        vCur.pop_back();
    }
}

vector<vector<int>> subsetsWithDup(vector<int>& nums) 
{
    sort(nums.begin(), nums.end());
    vector<vector<int>> vRet;
    vector<int> vCur;
    unordered_set<string> sBuff;
    subsetsWithDupBT(0, vRet, vCur, nums, sBuff);
    return vRet;
}

결과

속도는 예상외로 괜찮게 나왔다.

하지만, string을 써서 set을 사용한 것이 조금 효율적이지 않게 느껴진다.

이 문제의 backtrack이 값을 쌓아 나가는 과정을 유심히 살펴 보자.

1, 2a, 2b, 3 - 2가 중복값이라고 가정하고, 구분을 위해 2a, 2b로 두었다.

위 backtrack 로직을 가동하면,

0 1 2 3 4 - backTrack Func idx

[] - [1] - [1,2a] - [1,2a,2b] - [1,2a,2b,3] - 0

- [1,2a,3] - 1

- [1,2b] - [1,2b,3] - 2

-[2a]-[2a,2b]-[2a,2b,3] - 3

-[2a,3] - 4

-[2b]-[2b,3] - 5

-[3] - 6

모든 back track으로 만들 수 있는 조합 가운데,

위 붉은 색의 경우 중복으로 더 이상 진행 할 필요가 없음을 알았다.

문제는, 어떻게 저 경우는 걸러 내느냐 하는 것일 것이다.

보면, 추가하려는 대상값이 그 직전 값과 같고,

backTrack()에서 인자로 넘어오는 index가 for로 인해 증가할 때, 문제가 생기는 것을 알 수 있다.

따라서 if( iter_idx > backtrack_index && nums[iter_idx-1] != nums[iter_idx])

일때 더 이상 진행을 하지 않으면 될 것이다.

코드

void subsetsWithDupBT(int idx, vector<vector<int>>& vRet, vector<int>& vCur, vector<int>& nums)
    {
        vRet.push_back(vCur);
        if (idx >= nums.size())
            return;
        
        for (int q = idx; q < nums.size(); ++q)
        {
            // 이 경우 중복이 생기므로, 제외한다.
            if(q>idx && nums[q-1]==nums[q])
                continue;
            
            vCur.push_back(nums[q]);
            subsetsWithDupBT(q + 1, vRet, vCur, nums);
            vCur.pop_back();
        }
    }
    
    vector<vector<int>> subsetsWithDup(vector<int>& nums) 
    {
        sort(nums.begin(), nums.end());
        vector<vector<int>> vRet;
        vector<int> vCur;
        subsetsWithDupBT(0, vRet, vCur, nums);
        return vRet;
    }

결과