476-82（322、64、2、46、62、114）

322. 零钱兑换

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {


        //dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;

        for (int i = 0; i < coins.size(); i++)
        {
            for (int j = coins[i]; j <= amount; j++)
            {
                if (dp[j - coins[i]] != INT_MAX)
                {
                    dp[j] = std::min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX)   return -1;
        return dp[amount];
    }
};

64. 最小路径和

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();

        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i == 0 && j == 0)
                {
                    continue;
                }
                else if (i == 0)
                {
                    grid[i][j] = grid[i][j - 1] + grid[i][j];
                }
                else if (j == 0)
                {
                    grid[i][j] = grid[i - 1][j] + grid[i][j];
                }
                else
                {
                    grid[i][j] = std::min(grid[i][j - 1], grid[i - 1][j]) + grid[i][j];
                }
                
            }
        }
        return grid[m - 1][n - 1];
    }
};

2. 两数相加

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* cur = dummy;

        int temp = 0;

        while (l1 || l2 || temp)
        {
            if (l1)
            {
                temp += l1->val;
                l1 = l1->next;
            }
            if (l2)
            {
                temp += l2->val;
                l2 = l2->next;
            }

            cur->next = new ListNode(temp % 10);
            cur = cur->next;
            temp /= 10;
        }
        return dummy->next;
    }
};

46. 全排列

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;

    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        if (nums.size() == path.size())
        {
            res.push_back(path);
            return;
        }

        for (int i = 0; i < nums.size(); i++)
        {
            if (used[i] == true)
            {
                continue;
            }
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        res.clear();
        path.clear();

        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};

62. 不同路径

class Solution {
public:
    int uniquePaths(int m, int n) {
        //dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
        vector<vector<int>> dp(m, vector<int>(n, 0));

        for (int i = 0; i < n; i++)  dp[0][i] = 1;
        for (int i = 0; i < m; i++)  dp[i][0] = 1;

        for (int i = 1; i < m; i++)
        {
            for (int j = 1; j < n; j++)
            {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

114. 二叉树展开为链表

class Solution {
private:
    vector<TreeNode*> vec;

    void pre_traversal(TreeNode* root)
    {
        if (root == nullptr)
        {
            return;
        }

        vec.push_back(root);

        pre_traversal(root->left);
        pre_traversal(root->right);
    }

public:
    void flatten(TreeNode* root) {

        if(root == nullptr) return;
        pre_traversal(root);

        int n = vec.size();

        TreeNode* dummy = new TreeNode(-1);
        dummy->right = vec[0];
        
        TreeNode* cur = vec[0];
        for (int i = 0; i < n - 1; i++)
        {
            cur->right = vec[i + 1];
            cur->left = nullptr;
            cur = cur->right;
        }

        cur->left = nullptr;
        cur->right = nullptr;

        root = dummy->right;
    }
};