地址https://leetcode-cn.com/problems/minimum-number-of-days-to-eat-n-oranges/

廚房裡總共有 n個橘子，你決定每一天選擇如下方式之一吃這些橘子：

吃掉一個橘子。
如果剩餘橘子數 n能被 2 整除，那麼你可以吃掉 n/2 個橘子。
如果剩餘橘子數n能被 3 整除，那麼你可以吃掉 2*(n/3) 個橘子。
每天你只能從以上 3 種方案中選擇一種方案。

請你返回吃掉所有 n個橘子的最少天數。



示例 1：

輸入：n = 10
輸出：4
解釋：你總共有 10 個橘子。
第 1 天：吃 1 個橘子，剩餘橘子數 10 - 1 = 9。
第 2
 
 天：吃 6 個橘子，剩餘橘子數 9 - 2*(9/3) = 9 - 6 = 3。（9 可以被 3 整除）
第 3 天：吃 2 個橘子，剩餘橘子數 3 - 2*(3/3) = 3 - 2 = 1。
第 4 天：吃掉最後 1 個橘子，剩餘橘子數 1 - 1 = 0。
你需要至少 4 天吃掉 10 個橘子。
示例 2：

輸入：n = 6
輸出：3
解釋：你總共有 6 個橘子。
第 1 天：吃 3 個橘子，剩餘橘子數 6 - 6/2 = 6 - 3 = 3。（6 可以被 2 整除）
第 2 天：吃 2 個橘子，剩餘橘子數 3 - 2*(3/3) = 3 - 2 = 1。（3 可以被 3 整除）
第 3 天：吃掉剩餘 1
 
 個橘子，剩餘橘子數 1 - 1 = 0。
你至少需要 3 天吃掉 6 個橘子。
示例 3：

輸入：n = 1
輸出：1
示例 4：

輸入：n = 56
輸出：6


提示：

1 <= n <= 2*10^9

演算法1
不考慮 資料範圍的話，就是一個3n+1的模擬題。
考慮到資料範圍，可以使用適合的加速
使用BFS 從n向0靠近，bfs可以保證第一次進入佇列的距離是最短距離。
我們使用map記錄已經計算出的最短距離，避免重複計算。

class Solution {
public:

unordered_map<int, int> mm;
queue<pair<int
 
, int>> q;
int minDays(int n) {
    q.push({ n,0 });

    while (q.size())
    {
        int t = q.front().first;
        int step = q.front().second;
        q.pop();
        if (0 == t) break;
        if (t % 2 == 0  && mm.count(t/2) == 0 ) {
            q.push({ t / 2,step + 1 });
            mm[t / 2] = step + 1;
        }

        if ( t % 3 == 0 && mm.count(t/3) == 0 ) {
            q.push({ t / 3,step + 1 });
            mm[t / 3] = step + 1;
        }

        if ( t != 0 && mm.count(t-1) == 0  ) {
            q.push({ t - 1,step + 1 });
            mm[t - 1] = step + 1;
        }
    }

    return mm[0];
}

};

演算法2
貪心
計算過程中 只有減少1/2 減少2/3 減1 。
同時還有隱藏的操作 減1再減少1/2。 減1再減少2/3. 減2在減少2/3.
最後再考慮減1 的操作。
優先考慮減少1/2 1/3 能更快的接近結果，使用記憶化避免重複計算。

class Solution {
public:


    int  dp[50000] = { 0 };
int dfs(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;

    if (n < 50000 && dp[n] != 0) return dp[n];
    int ans = 99999999;
    int flag = 0;
    if (n % 2 == 0) {
        ans = min(ans, 1 + dfs(n / 2));
        flag = 1;
    }

    if (n % 3 == 0) {
        ans = min(ans, 1 + dfs(n / 3));
        flag = 1;
    }

    if ((n - 1) % 3 == 0) {
        ans = min(ans, 2 + dfs((n - 1) / 3));
        flag = 1;
    }

    if ((n - 2) % 3 == 0) {
        ans = min(ans, 3 + dfs((n - 2) / 3));
        flag = 1;
    }

    if ((n - 1) % 2 == 0) {
        ans = min(ans, 2 + dfs((n - 1) / 2));
        flag = 1;
    }

    if (flag == 0) {
        ans = min(ans, 1 + dfs(n - 1));
    }
    if (n < 50000)
        dp[n] = ans;
    return ans;
}

int minDays(int n) {
    return dfs(n);
}


};