LeetCode - Permutations II

最新推荐文章于 2019-03-26 13:08:28 发布

转载最新推荐文章于 2019-03-26 13:08:28 发布 · 48 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/Jerrymingzj/blog/803817

文章标签：

#数据结构与算法 #python

本文针对LeetCode上的排列组合问题（含重复元素），提供两种高效的回溯算法实现方案。一种是使用额外的布尔数组记录已访问的元素，另一种则是直接在原数组上进行标记。通过对比这两种方法，展示如何优化代码以提高执行效率。

2019独角兽企业重金招聘Python工程师标准>>>

题目链接：https://leetcode.com/problems/permutations-ii/

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,
[1,1,2] have the following unique permutations:
[1,1,2], [1,2,1], and [2,1,1].

题目大意，列出所有非重复的排列组合。一般采用回溯（backtracking）递归求解，对于递归过程中标记已访问的数据有两种方法，一是开辟数组vis[]，二是利用原数据数组，显然第二种效率高一些，具体耗时为一（32ms），二（28ms）。第一种方法比较容易想到，一开始是我也只想到这一种，所以写博客记录一下思维的差距。

I 开辟vis[]数组

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int> > ret;
        if(nums.empty())
            return ret;
        sort(nums.begin(), nums.end());
        vector<bool> vis(nums.size(), false);
        vector<int> tmp;
        dfs(ret, nums, tmp, vis);
        return ret;
    }

    void dfs(vector<vector<int> > &ret, vector<int> &nums, vector<int> &tmp, vector<bool> &vis)
    {
        if(tmp.size() == nums.size()) {
            ret.push_back(tmp);
            return;
        }
        else {
            for(int i = 0; i < nums.size(); i++) {
                if(vis[i] == true)
                    continue;
                if(i > 0 && vis[i - 1] == false && vis[i] == false && nums[i] == nums[i - 1])
                    continue;
                tmp.push_back(nums[i]);
                vis[i] = true;
                dfs(ret, nums, tmp, vis);
                vis[i] = false;
                tmp.pop_back();
            }
        }
    }
};

II. 利用原数据数组标记

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int> > ret;
        if(nums.empty())
            return ret;
        sort(nums.begin(), nums.end()); //this is not necessary, but can raise efficiency
        dfs(ret, nums, 0);
        return ret;
    }

    //nums[0, begin) is visted, nums[begin, end] is not
    void dfs(vector<vector<int> > &ret, vector<int> &nums, int begin)
    {
        if(begin == nums.size() - 1) {
            ret.push_back(nums);
            return;
        }
        else {
            for(int i = begin; i < nums.size(); i++) {
                bool flag = false; // exit nums[j] == nums[i], where j range of [begin, i) ?
                for(int j = begin; j < i; j++) {
                    if (nums[i] == nums[j]) {
                        flag = true;
                        break;
                    }
                }
                if(flag == true)
                    continue;
                swap(nums[i], nums[begin]);
                dfs(ret, nums, begin + 1);
                swap(nums[i], nums[begin]);
            }
        }
    }
};

转载于:https://my.oschina.net/Jerrymingzj/blog/803817