Untitled

class Solution {
public:
    int max3(int a, int b, int c) { return max(a, max(b, c)); }
    int min3(int a, int b, int c) { return min(a, min(b, c)); }
    int max3exclude(int a, int b, int c, int cur_max) {
        int res = 0;
        if (a != cur_max) res = max(a, res);
        if (b != cur_max) res = max(b, res);
        if (c != cur_max) res = max(c, res);
        return res;
    }
    int min3exclude(int a, int b, int c, int cur_min) {
        int res = INT_MAX;
        if (a != cur_min) res = min(a, res);
        if (b != cur_min) res = min(b, res);
        if (c != cur_min) res = min(c, res);
        return res;
    }

    int left3(int a, int b, int c) {
        return max3(a, b, c) + min3(a, b, c);
    }

    int left2(int a, int b) {
        return max(a, b);
    }

    int minCost(vector<int>& nums) {
        if (nums.size() == 3) {
            return left3(nums[0], nums[1], nums[2]);
        } else if (nums.size() == 2) {
            return left2(nums[0], nums[1]);
        } else if (nums.size() == 1) return nums[0];

        int cost = 0, cur_max, cur_min;
        for (int i = 1, left = nums[0]; i < nums.size(); i += 2) {
            // handle edge cases
            if (i == nums.size() - 1) {
                cout << "case left 2" << endl;
                cost += left2(left, nums[i]);
                break;
            }
            if (i == nums.size() - 2) {
                cout << "case left 3" << endl;
                cost += left3(left, nums[i], nums[i + 1]);
                break;
            }
            if (i == nums.size() - 3) {
                cout << "case left 4" << endl;
                cur_max = max3(left, nums[i], nums[i + 1]);
                cur_min = min3(left, nums[i], nums[i + 1]);
                // sneak cur max to next round
                if (cur_max <= nums[i + 2]) {
                    cost += max3exclude(left, nums[i], nums[i + 1], cur_max);
                    left = cur_max;
                    cout << "cost: " << cost << endl;
                } else { // discard the max two nums, leave min to next round
                    cost += max3exclude(left, nums[i], nums[i + 1], cur_min);
                    left = cur_min;
                }
                continue;
            }

            cout << "case usual" << endl;
            cur_max = max3(left, nums[i], nums[i + 1]);
            cur_min = min3(left, nums[i], nums[i + 1]);
            // sneak cur max to next round
            if (cur_max < max(nums[i + 2], nums[i + 3])) {
                cost += max3exclude(left, nums[i], nums[i + 1], cur_max);
                left = cur_max;
                cout << "cost: " << cost << endl;
            } else { // discard the max two nums, leave min to next round
                cost += max3exclude(left, nums[i], nums[i + 1], cur_min);
                left = cur_min;
            }
            continue;
        }
        return cost;
    }
};©leetcode