代码随想录算法训练营第二十九天|491.递增子序列、46.全排列、47.全排列 II

491.递增子序列

public class Solution {
        List<int> path=new List<int>();
        List<IList<int>> result=new List<IList<int>>();
    public IList<IList<int>> FindSubsequences(int[] nums) {
        backtracking(nums,0);
        return result;
    }
    public void backtracking(int[] nums,int startIndex)
    {
           if(path.Count>1)
            result.Add(new List<int>(path));
            Dictionary<int,int> dic=new Dictionary<int,int>();
        for(int i=startIndex;i<nums.Length;i++)
        {
            if(path.Count!=0&&nums[i]<path[path.Count-1]||dic.ContainsKey(nums[i]))
            {
              continue;
            }
            dic.Add(nums[i],1);
            path.Add(nums[i]);
            backtracking(nums,i+1);
            path.RemoveAt(path.Count-1);
        }
    }
}

收获条件是Path里面至少有两个元素，同时Path为空并且待传入的小于Path的最后一个元素或者已经被收录了就都跳过（用一个字典来检验是否被收录）。

46.全排列

public class Solution {
    List<int> path=new List<int>();
     List<IList<int>> result=new List<IList<int>>();
     bool[] used;
    public IList<IList<int>> Permute(int[] nums) {
        used=new bool[nums.Length];
        for(int i=0;i<used.Length;i++)  
        {  
            used[i]=false; 
        }
        backtracking(nums,used);
        return result;
    }
    public void backtracking(int[] nums,bool[] used)
    {
        if(path.Count==nums.Length)
        {
        result.Add(new List<int>(path));
        return;
        }
    for(int i=0;i<nums.Length;i++)
    {
        if(used[i])
        continue;
        used[i]=true;
        path.Add(nums[i]);
        backtracking(nums,used);
        path.RemoveAt(path.Count-1);
        used[i]=false;
    }
    }
}

全排列不是组合故此用不到Startindex，收获条件则是Path长度和数组长度一样，需要一个Used数组来记录当前元素是否被收录，被收录则跳过，去收录另外的即可。

47.全排列 II

public class Solution {
     List<int> path=new List<int>();
     List<IList<int>> result=new List<IList<int>>();
     bool[] used;
    public IList<IList<int>> PermuteUnique(int[] nums) {
        used=new bool[nums.Length];
        for(int i=0;i<used.Length;i++)  
        {  
            used[i]=false; 
        }
        Array.Sort(nums);
        backtracking(nums,used);
        return result;
    }
    public void backtracking(int[] nums,bool[] used)
    {
        if(path.Count==nums.Length)
        {
        result.Add(new List<int>(path));
        return;
        }
    for(int i=0;i<nums.Length;i++)
    {
        if(i>0&&used[i-1]==false&&nums[i]==nums[i-1])
        {
            continue;
        }
        if(used[i]==false)
        {
        used[i]=true;
        path.Add(nums[i]);
        backtracking(nums,used);
        path.RemoveAt(path.Count-1);
        used[i]=false;
        }
        
    }
    }
    }

在上一题的基础上因为不能用重复的元素所以需要对其进行排序操作并且相邻元素相同并且前一个为False则要跳过，树层上如果当前元素Used数组为False则说明未使用，那就加入到Path当中，回溯操作后要变回False。