2021-06-10Leetcode216、377

• 依然是要抓住24个字母char，这里用map，
• 注意map.second这个可以是0，但为0不可以，要判断！！ 

class Solution {
public:
int ans;
    int numTilePossibilities(string tiles) {
        map<char, int> dict;
        for(auto a: tiles){
            dict[a]++;
        }
        backtracking(dict);
        return ans;
    }

    void backtracking(map<char, int> dict){
        for(auto &a: dict){
            if(a.second>0){
                ans++;
                a.second--;
                backtracking(dict);
                a.second++;
            }
        }
    }
}

//chaohao
class Solution {
public:
int ans;

    int numTilePossibilities(string tiles) {
        int dict[26];
        memset(dict, 0, sizeof(dict));
        for(auto a: tiles){
            dict[a-'A']++;
        }
        backtracking(dict);
        return ans;
    }

    void backtracking(int* dict){
        for(int i=0; i< 26; i++){
            if(dict[i]>0){
                dict[i]--;
                ans++;
                backtracking(dict);
                dict[i]++;
            }
        }
    }
};

• int数组的引用方法！！
• memset必须要分配空间才行！

216.

• 为何超时间限制？
• 由于数字只能用一次，隐含了顺序这个条件！

class Solution {
public:
vector<vector<int>>  ans;
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k, n, {});
        return ans;
    }

    void backtracking(int k, int n, vector<int> vt){
        if(k == 0 && n==0) ans.push_back(vt);
        for(int i=1; i< 10; i++){
            vt.push_back(i);
            backtracking(k-1, n-i, vt);
            vt.pop_back();
        }
    }
};


......
class Solution {
public:
vector<vector<int>>  ans;
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k, n,1, {});
        return ans;
    }

    void backtracking(int k, int n,int index,  vector<int> vt){
        if(k == 0 && n==0) ans.push_back(vt);
        if(index>n || k<0) return;
        for(int i=index; i< 10; i++){
            vt.push_back(i);
            backtracking(k-1, n-i,i, vt);
            vt.pop_back();
        }
    }
};

正确但效率极低！
class Solution {
public:
vector<vector<int>>  ans;
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k, n,1, {});
        return ans;
    }

    void backtracking(int k, int n,int index,  vector<int> vt){
        if(k == 0 && n==0) ans.push_back(vt);
        if(index>n || k<0) return;
        for(int i=index; i< 10; i++){
            vt.push_back(i);
            backtracking(k-1, n-i,i+1, vt);
            vt.pop_back();
        }
    }
};

• 差别只有这一句话！ 

backtracking(k-1, n-i,i+1, vt);

这种做法出现了重复数字？？

377.

能通过一半？？超出时间限制？

class Solution {
public:
int ans; 
    int combinationSum4(vector<int>& nums, int target) {
        backtracking(nums, target);
        return ans;
    }

    void backtracking(vector<int>& nums, int target){
        if(target == 0) ans++;
        if(target<0) return;
        for(auto a: nums){
            int tmp = target;
            backtracking(nums, target-a);
            target = tmp;
        }
    }
};

• 竟然用动态规划？？！！ 

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1, 0);
        dp[0] = 1;
        for (int i = 0; i <= target; i++) { // 遍历背包
            for (int j = 0; j < nums.size(); j++) { // 遍历物品
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

......lack some
class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target+1, 0);
        dp[0]=1;
        for(int i=1; i<= target; i++){
            for(auto a: nums){
                if(i-a >= 0 ){
                    dp[i] = dp[i-a];
                }
            }
        }
        return dp[target];
    }
};

dp[i] = dp[i-a];

• 这一句是加号哦！！！ 
• 没有哪个INT_MAX,就只能通过14个？

 

死亡？？？？