2021-06-11 Leetcode491、60

 

如何解决string 去除一个字符问题！？

https://www.bilibili.com/video/BV1AJ411a7fB?from=search&seid=16572044708874072107

• 还是用一个vector来mark效果最好！！

class Solution {
public:
vector<string> vt;
    string getPermutation(int n, int k) {
        set<int> dict;
        for(int i=1; i<=n; i++){
            dict.insert(i);
        }
        backtracking(dict, "");
        return vt[k-1];
    }

    void backtracking(set<int> dict, string ss){
        if(dict.empty()){
            vt.push_back(ss);
            return;
        }
        for(auto a: dict){
            ss += a;
            dict.erase(a);
            backtracking(dict, ss);
            ss.pop_back();
            dict.insert(a);
        }
    }
};

//回溯写法
class Solution 
{
    StringBuilder path;
    List<String> res;
    int count=0;
    public String getPermutation(int n, int k) 
    {
        path = new StringBuilder();
        res = new ArrayList<>();
        boolean[] visited = new boolean[n+1];
        dfs(n,visited,k);
        return res.get(0);
    }

    public void dfs(int n,boolean[] visited,int k)
    {
        if(path.length()==n)
        {
            count++;
            if(count==k)
            {
                res.add(new String(path));
            }
            return;
        }
        for(int i=1;i<=n;i++)
        {
            if(visited[i])
            {
                continue;
            }

            path.append(i);
            visited[i]=true;

            dfs(n,visited,k);

            path.deleteCharAt(path.length()-1);
            visited[i]=false;
            
            if(res.size()!=0)
            {
                return;
            }
        }
    }
}

class Solution {
public:
    string getPermutation(int n, int k) {
        vector<int> vis(n, 0);
        vector<int> result;
        int no = 0;
        helper(vis, result, no, k);
        string ans;
        for(auto n: result){
            ans += to_string(n);
        }
        return ans;
    }

    bool helper(vector<int>& vis, vector<int> &result, int& no, int target){
        if(result.size()==vis.size()){
            if(++no == target){
                return true;
            }
            return false;
        }
        for(int i=1; i<=vis.size(); i++){
            if(vis[i-1]) continue;
            vis[i-1] = 1;
            result.push_back(i);
            bool next = helper(vis, result, no, target);
            if(next) return true;
            result.pop_back();
            vis[i-1] = 0;
        }
        return false;
    }
};

及时退出之法！！ 

if(helper(vis, result, no, target)) return true;

 

109个，超出时间限制！如用标记法，未及时退出 

class Solution {
public:
vector<int> vt;
    string getPermutation(int n, int k) {
        vector<bool> vis(n, false);
        vector<int> result;
        int no = 0;
        helper(vis, result, no, k);
        string ans;
        for(auto n: vt){
            ans += to_string(n);
        }
        return ans;
    }

    bool helper(vector<bool>& vis, vector<int> &result, int& no, int target){
        if(result.size()==vis.size()){
            if(++no == target){
                vt = result;        //如何中止后边的循环？
                return true;
            }
            return false;   //false继续，而true就中止了
        }
        for(int i=1; i<=vis.size(); i++){
            if(vis[i-1]) continue;
            vis[i-1] = true;
            result.push_back(i);
            bool mb = helper(vis, result, no, target); 
            if(mb) return true;
            result.pop_back();
            vis[i-1] = false;
        }
        return false;
    }
};

这个还是超了时间，但达到200、200，最后一个不通过，返回true时，可剪枝。 

class Solution {
public:
vector<int> vt;
    string getPermutation(int n, int k) {
        vector<bool> vis(n, false);
        vector<int> result;
        int no = 0;
        helper(vis, result, no, k);
        string ans;
        for(auto n: vt){
            ans += to_string(n);
        }
        return ans;
    }

    void helper(vector<bool>& vis, vector<int> &result, int& no, int target){
        if(result.size()==vis.size()){
            if(++no == target){
                vt = result;        //如何中止后边的循环？
            }
            return;
        }
        for(int i=1; i<=vis.size(); i++){
            if(vis[i-1]) continue;
            vis[i-1] = true;
            result.push_back(i);
            helper(vis, result, no, target);
            result.pop_back();
            vis[i-1] = false;
        }
    }
};

31.

看不到回溯的影子？

• 找一段在递增的区间里找。
• 找到那个刚好比它大的值，两者互换！

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int i = nums.size() - 2;
        while (i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.size() - 1;
            while (j >= 0 && nums[i] >= nums[j]) {
                j--;
            }
            swap(nums[i], nums[j]);
        }
        reverse(nums.begin() + i + 1, nums.end());
    }
};

491.

老毛病了，去重问题？

 

class Solution {
public:
vector<vector<int>> ans;

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        backtracking(nums, {}, 0);
        return ans;
    }

    void backtracking(vector<int>& nums, vector<int> vt, int index){
        if(vt.size() >=2) ans.push_back(vt);
        for(int i = index; i<nums.size(); i++){
            vt.push_back(nums[i]);
            backtracking(nums, vt, i+1);
            vt.pop_back();
        }
    }
};

.....以上错了，以下也错了
class Solution {
public:
set<vector<int>> ans;

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        backtracking(nums, {}, 0);
        return vector<vector<int>>(ans.begin(), ans.end());
    }

    void backtracking(vector<int>& nums, vector<int> vt, int index){
        if(vt.size() >=2) ans.insert(vt);
        for(int i = index; i<nums.size(); i++){
            vt.push_back(nums[i]);
            backtracking(nums, vt, i+1);
            vt.pop_back();
        }
    }
};

• backtracking(,,i+1)注意这里不是index
• 可以用左值！return那里，vector< 

class Solution {
public:
set<vector<int>> ans;

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        //sort(nums.begin(), nums.end());
        backtracking(nums, {}, 0);
        return vector<vector<int>>(ans.begin(), ans.end());
    }

    void backtracking(vector<int>& nums, vector<int> vt, int index){
        if(vt.size() >=2) ans.insert(vt);
        for(int i = index; i<nums.size(); i++){
            if(!vt.empty() && nums[i]< vt.back()) continue;
            vt.push_back(nums[i]);
            backtracking(nums, vt, i+1);
            vt.pop_back();
        }
    }
};

646.

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        int m = pairs.size();
        int n = pairs[0].size();
        sort(pairs.begin(), pairs.end(), [=](const vector<int> a, const vector<int> b){
            return (a[1]<b[1] && a[0]==b[0]) || (a[0]<b[0]);
        });
        vector<int> dp(m, 1);
        int ans = 0;
        for(int i=0; i<m; i++){
            for(int j = 0; j<i; j++){
                 if(pairs[i][0]> pairs[j][1]){
                     dp[i] =max(1+dp[j], dp[i]); 
                 }
            }
            ans = max(ans, dp[i]); //不一定是在最后一个位置出现最大值。
        }
    return ans;
    }
};

[1,2] -> [3,4]同下面这句照照镜子就可以。

 if(pairs[i][0]>pairs[j][1]){

初始化的那会！是0 

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        int m = pairs.size();
        int n = pairs[0].size();
        sort(pairs.begin(), pairs.end(), [=](const vector<int> v1, const vector<int> v2){
            return (v1[1]<v2[1] && v1[0]==v2[0]) || (v1[0]<v2[0]);
        });
        vector<int> dp(m+1, 1);
        int ans = 0;
        for(int i=0; i< m; i++){
            for(int j=0; j<i; j++){
                if(pairs[i][0]>pairs[j][1]){
                    dp[i] = max(dp[j]+1, dp[i]);
                }
                
            }
            ans = max(dp[i], ans);
        }
        return ans;
    }
};

797.

 

class Solution {
    vector<vector<int>> res;
    vector<int> tmp;
public:
    void DFS(vector<vector<int>>& graph,int k)
    {
        if(k==graph.size()-1)
        {
            res.push_back(tmp);
            return;
        }

        for(int i=0;i<graph[k].size();i++)
        {
            tmp.push_back(graph[k][i]);
            DFS(graph,graph[k][i]);
            tmp.pop_back();
        }
    }
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        tmp.push_back(0);
        DFS(graph,0);
        return res;
    }
};

为何出现这种错误？？ 

• 全是以0开头的！！末尾在哪呢？怎么出去呢

class Solution {
public:
vector<vector<int>> ans;
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        dfs(graph, {}, 0);
        return ans;
    }

    void dfs(vector<vector<int>>& graph, vector<int> path, int index){
        if(graph[index].empty()==true){
            ans.push_back(path);
            return;
        }
        for(int i=0; i<graph[index].size(); i++){
            path.push_back(graph[index][i]);
            dfs(graph, path, graph[index][i]);
            path.pop_back();
        }
    }
};

为何最终出去的条件是？？ 

class Solution {
private:
    // i表示当前的点
    // n表示点的数量，也是结束标志
    // res是结果
    // curr是当前的路径
    vector<vector<int>> res;
    void dfs(int i, vector<int>& curr, const vector<vector<int>>& graph)
    {
        if (i < graph.size()-1)
        {
            for (int next : graph[i])
            {
                curr.push_back(next);
                dfs(next,curr, graph);
                // 记得回溯
                curr.pop_back();
            }
        }
        else
        {
            // 递归结束了
            res.push_back(curr);
        }
    }

public:
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        
        // 初始从0开始
        vector<int> curr{0};
        int n = graph.size();
        dfs(0,curr, graph);
        return res;
    }
};