Leetcode13、90、78、717、89、10、14回溯子集和罗马数字

• 试的顺序一定是先从大的，一直试到小的
• s = s.substr(), 前面必须有s=做接受才行。
• while循环，第一个匹配不上，从大到小继续去匹配。
• 一直匹配大的数字，匹配到后来前面的大数不必匹配的

class Solution {
public:
    int romanToInt(string s) {
        int num[]={1000,900,500,400,100,90,50,40,10,9,5,4,1};
        string temp[]={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
        int ans=0;
        for(int i=0;i<13;i++)
        {
            while(s.find(temp[i])==0)
            {
                ans+=num[i];
                s=s.substr(temp[i].length());
            }
        }
        return ans;
    }
};

14.

• 巧用string自身的find去找自身，再前缀公共的
• 每一个都去找它的前缀，随便取一个作为前缀
• while是不找到这两个之间的公共前缀不罢休！！但这个符合了，vector中还有多少个需要？？

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int n = strs.size();
        if(n==0) return "";
        string s = strs[0];
        for(int i=0; i<strs.size(); i++){
            while(strs[i].find(s)!=0){
                s = s.substr(0, s.length()-1);
                if(s=="") return "";
            }
        }
        return s;
    }
};

10.一直不会！！！

89

89.

 

 

717.

• while循环，设立一个初始的k=0，往后走
• 如果走到最有以为是0
• 看它最后停留状态，如果是刚好最后一位就。

  return start == bits.length-1;

class Solution {
public:
    bool isOneBitCharacter(vector<int>& bits) {
        int n = bits.size();
        int k = 0;
        bool ans = false;
        while(k<n){
            if(k==n-1 && bits[k]==0) ans = true;
            if(bits[k]==0) k += 1;
            else k += 2;
        }
        return ans;
    }
};

78.

vector中查找一个元素在其中, 

if (std::find(v.begin(), v.end(), key) != v.end())

• 对于每个元素，两个选择：选他或者不选他， 即dfs衍生出两种情况。
• popback出去掉那种情况，这就是随机挑选。

class Solution {
public:
vector<vector<int>> ans;
    vector<vector<int>> subsets(vector<int>& nums) {
        ans.push_back({});
        dfs(0, nums, {});
        return ans;
    }

    void dfs(int index,vector<int>& nums, vector<int> tmp){
        if(index == nums.size()) return; //index = n-1还可以处理呢
        tmp.push_back(nums[index]);
        ans.push_back(tmp);
        dfs(index+1, nums, tmp); //包含当前元素
        tmp.pop_back();         //pop掉之后就是不包含当前元素的了
        dfs(index+1, nums, tmp);
        return;
    }
};


//更好，同下题思路
class Solution {
public:
vector<vector<int>> ans;
vector<int> tmp;
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return ans;
    }

    void dfs(vector<int>& nums, int start){
        ans.push_back(tmp);
        for(int j=start; j<nums.size(); j++){
            tmp.push_back(nums[j]);
            dfs(nums, j+1);
            tmp.pop_back();
        }
    }
};

90.延申为1-2如何去重？去重想想先排序，就聚集了

• 先进行排序，保证重复元素挨在一起

• dfs(nums, j+1); 回溯中的index+1， 选择了当前这个值。
• 去重操作初往往排序，j和j-1就开始进行 continue
• 使用回溯，但不是限定多少个的回溯。ans.push_back在每一次调用dfs时就放进去了

class Solution {
public:
vector<vector<int>>  ans;
vector<int> tmp;
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        dfs(nums,0);
        return ans;
    }

    void dfs(vector<int>& nums,int start){
        ans.push_back(tmp);
        for(int j= start; j<nums.size(); j++){
            if(j!=start && nums[j]==nums[j-1]) continue;
            tmp.push_back(nums[j]);
            dfs(nums, j+1);
            tmp.pop_back();
        }
        
    }
};