找工作准备刷题Day12 回溯算法+动态规划 (卡尔41期训练营 7.26）

久未

已于 2024-07-26 16:19:22 修改

阅读量588

点赞数 12

文章标签：算法动态规划

于 2024-07-26 16:18:30 首次发布

本文链接：https://blog.csdn.net/weixin_44604409/article/details/140717090

版权

第一题：Leetcode93. 复原 IP 地址

题目描述

题解——回溯法

class Solution {
public:
    vector<vector<string>> rec;
    vector<string> path;
    vector<string> restoreIpAddresses(string s) {
        if (s.size() < 4 || s.size() > 12)
            return {};

        backTracking(s, 0);
        vector<string> ans;
        for (auto r : rec) {
            string str;
            for (int i = 0; i < r.size(); i++) {
                if (i > 0)
                    str += ".";
                str += r[i];
            }
            ans.push_back(str);
        }
        return ans;
    }

    void backTracking(const string s, int startIdx) {
        if (path.size() == 4 && startIdx == s.size()) {
            rec.push_back(path);
            return;
        }
        if (startIdx >= s.size() || path.size() >= 4)
            return;

        for (int i = startIdx; i <= startIdx + 2; i++) {
            string substr = s.substr(startIdx, i - startIdx + 1);
            if (isValidAddress(substr)) {
                path.push_back(substr);
                backTracking(s, i + 1);
                path.pop_back();
            }
        }
    }

    bool isValidAddress(const string substr) {
        // 写法一
        // if (substr == "" || (substr[0] == '0' && substr.size() > 1))
        //     return false;

        // int num = 0;
        // for (int i = 0; i < substr.size(); i++) {
        //     if (substr[i] > '9' || substr[i] < '0')
        //         return false;
        //     num = num * 10 + (substr[i] - '0');
        //     if (num > 255)
        //         return false;
        // }
        // return true;

        // 写法二
        if (substr == "" || (substr[0] == '0' && substr.size() > 1))
            return false;

        if (substr[0] == '0' && substr.size() == 1)
            return true;

        int n = atoi(substr.c_str());
        if (n > 0 && n <= 255)
            return true;
        return false;
    }
};

解题要点

IPV4是由四段组成，可以提前剪枝
需要注意类似 0.0.0.0是合法的，要对只有一个零的string进行区分；
复习 string s.substr(startIdx,length）用法：返回s中以startIdx为下标，长度为length的子串
atoi用法：将一个数转为int，如果不合法，则返回0，需要与IP地址中的0区分开。

第二题：Leetcode78. 子集

题目描述

题解

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums) {
        ans.reserve(1<<(nums.size()));
        backTacking(nums, 0);
        return ans;
    }

    void backTacking(const vector<int>& nums, int startIdx) {
        ans.push_back(path);
        if (startIdx == nums.size()) {
            return;
        }

        for (int i = startIdx; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backTacking(nums, i + 1);
            path.pop_back();
        }
    }
};

Tips

注意 ans.push_back(path)的位置，每次回溯均push，与之前的不同。
使用reserve预先分配存储空间，避免反复扩容量，提高程序速度，但是，实际运用需要处理异常，如果内存不够会 bad alloc。

第三题：Leetcode90. 子集 II

题目描述

题解

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        ans.reserve(1 << (nums.size()));
        sort(nums.begin(), nums.end());
        backTacking(nums, 0);
        return ans;
    }

    void backTacking(const vector<int>& nums, int startIdx) {
        ans.push_back(path);
        if (startIdx == nums.size()) {
            return;
        }

        for (int i = startIdx; i < nums.size(); i++) {
            if (i > startIdx && nums[i] == nums[i - 1])
                continue;
                
            path.push_back(nums[i]);
            backTacking(nums, i + 1);
            path.pop_back();
        }
    }
};

与上一题区别：nums中存在重复元素

因此首先对nums进行排序，其次在同一层遍历用，跳过相同元素（见continue语句）

第四题：卡尔网 01背包问题

题目描述

题解1——二维递归数组

#include <iostream>
#include <vector>
using namespace std;
// 二维数组方法
int main()
{
    int m, bagWeight;
    cin >> m >> bagWeight;
    vector<int> weight(m), value(m);
    for (int i = 0; i < m; i++)
        cin >> weight[i];
    for (int i = 0; i < m; i++)
        cin >> value[i];

    // initialize
    vector<vector<int>> dp(m, vector<int>(bagWeight + 1, 0));
    for (int j = weight[0]; j <= bagWeight; j++)
        dp[0][j] = value[0];

     for (int i = 1; i < m; i++)
    {
        for (int j = bagWeight; j >= 0; j--)
        {
            if (j < weight[i])
                dp[i][j] = dp[i - 1][j];
            else
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }

    cout << dp[m - 1][bagWeight] << endl;
    return 0;
}

要点

递归数组dp为m×(bagWeight+1)，dp[i][j]表示在背包容量为j、从[0,i]物品中挑选时最大可以装进去的value，其公式为 $dp(i,j) = \binom{dp(i-1,j),if j<weight(i)}{max(dp(i-1,j),dp(i-1,j-weight(i))+value(i)),if j\geqslant weight(i)}$
由于i依赖于i-1，所以i从0遍历到m-1；对于dp(i,j)，其依赖于dp(i-1,j)，在遍历时，j从大到小和从小到大均可。题解中，为了与一维数组相同，采用从后往前遍历。
初始化：需要初始化i为0时取值，对于j>=weight(0），dp赋值为value(0);对于j<weight(0),dp赋值为0。

题解2——一维数组

#include <iostream>
#include <vector>
using namespace std;
// 滚动数组方法
int main()
{
    int m, bagWeight;
    cin >> m >> bagWeight;
    vector<int> weight(m), value(m);
    for (int i = 0; i < m; i++)
        cin >> weight[i];
    for (int i = 0; i < m; i++)
        cin >> value[i];

    // initialize
    // vector<vector<int>> dp(m, vector<int>(bagWeight + 1, 0));
    vector<int> dp(bagWeight + 1, 0);

    for (int i = 0; i < m; i++)
    {
        // when j < weight[i], we do not change the value , so the loop ends
        for (int j = bagWeight; j >= weight[i]; j--)
        {
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }

    cout << dp[bagWeight] << endl;

    return 0;
}

要点

j需要从后往前遍历的原因是：对于在i = m, j = n时，dp[n]依赖于 i = m-1 时候的dp[j<n]。如果从前往后遍历，会修改上一层的dp值。
由于j<weight[i] 时，对dp数组不做任何操作，所以第二层for是：j from bagWeight downto weight[i]；

第五题：Leetcode416. 分割等和子集

题目描述

解题思路

将这个问题构造成01背包问题：

背包大小为target = sum/2；
物品为nums，weight和value均为nums数组元素取值；
这个背包问题描述为：有一个大小为 target 的背包，从nums数组中任意挑选不重复的数字，如果该背包最大装下的value之和为 target，那么代表可以将数组分成两个和相等的子集。

题解

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0);

        if (sum & 1) {
            cout << "sum%2 == 1" << endl;
            return false;
        }

        // cout << "sum: " << sum << endl;

        const int target = sum >> 1;
        vector<int> dp(target + 1, 0);

        for (int i = 0; i < nums.size(); i++) {
            for (int j = target; j >= nums[i]; j--)
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

            // for (int j = 0; j < dp.size(); j++)
            //     cout << dp[j] << " ";
            // cout << endl;
        }
        // cout<<dp[target]<<endl;
        // cout<<target<<endl;

        return dp[target] == target;
    }
};

Tips