第 i 個任務需要花費 tasks[i] 小時完成。一個 工作時間段 中，你可以 至多 連續工作 sessionTime 個小時，然後休息一會兒。

你需要按照如下條件完成給定任務：

• 如果你在某一個時間段開始一個任務，你需要在 同一個 時間段完成它。
• 完成一個任務後，你可以 立馬 開始一個新的任務。
• 你可以按 任意順序 完成任務。

給你 tasks 和 sessionTime ，請你按照上述要求，返回完成所有任務所需要的 最少 數目的 工作時間段 。

思路：一開始一維可以用貪心做，但是發現有特殊樣例沒過掉，

class Solution {
public:
    int minSessions(vector<int>& A, int sessionTime) {
        int n = A.size();
        multiset<int> st;
        for (int i = 0; i < n; ++i) {
            st.insert(sessionTime);
        }
        sort(A.begin(), A.end());
        int ans = 0;
        for (int i = n - 1; i >= 0; --i) {
            int a = A[i];
            auto it = st.lower_bound(a);
            if (*it == sessionTime) {
                ans++;
            }
            int r = *it - a;
            st.erase(it);
            if (r != 0) {
                st.insert(r);
            } 
        }
        return ans;
    }
};
 

遞迴列舉狀態：對於每個任務來說，要麼新開一個 session 去做、要麼在已經開了的 session 去執行，為了實現儲存，需要容器去儲存以前開啟了的 session：

class Solution {
public:
    int ans = INT_MAX;
    void dfs(int i, int sessionTime, vector<int> curSessions, vector<int>& A) {
        if (curSessions.size() >= ans) {
            return;
        }
        if (i >= A.size()) {
            ans = min(ans, (int) curSessions.size());
            return;
        }
        //在原有的session上做任務
        for (int j = 0; j < curSessions.size(); ++j) {
            if (A[i] + curSessions[j] <= sessionTime) {
                curSessions[j] += A[i];
                dfs(i + 1, sessionTime, curSessions, A);
                curSessions[j] -= A[i];
            }
        }
        //新開session
        curSessions.push_back(A[i]);
        dfs(i + 1, sessionTime, curSessions, A);
        curSessions.pop_back();
    }
    int minSessions(vector<int>& A, int sessionTime) {
        vector<int> curSessions;
        dfs(0, sessionTime, curSessions, A);
        return ans;
    }
};