dfs系列

组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。 
示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

void BackTrace(vector<vector<int>> &result, vector<int> &v, vector<int> candidates,
	int target, int remain, int begin);
vector<vector<int>> combinationSum(vector<int>& candidates, int target)
{
	vector<vector<int>> result;
	vector<int> v;
	BackTrace(result, v, candidates, target, target, 0);
	return result;
}
/*
result存放的是最后的结果
v里面存放的是某次成立的元素
candidates是题目给定的数组
target是给定的值
remain距离给定的值还差的大小
begin从哪个坐标开始
*/
void BackTrace(vector<vector<int>> &result, vector<int> &v, vector<int> candidates,
	int target, int remain, int begin)
{
	if (remain < 0)
		return;
	else if (remain == 0)
		result.push_back(v);
	else
	{
		for (int i = begin; i < candidates.size(); ++i)
		{
			v.push_back(candidates[i]);
			BackTrace(result, v, candidates, target, remain - candidates[i], i);
			//无论结果正确与否，为了进行下一次找寻，需要移除一位
			v.pop_back();
		}
	}
}

组合总和II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。 

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/*
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次 。
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
*/
//思路：对照39
void BackTrace(vector<vector<int>> &result, vector<int> &v, vector<int> candidates,
	int target, int remain, int begin);
vector<vector<int>> combinationSum2(vector<int>& candidates, int target)
{
	vector<vector<int>> result;
	vector<int> v;
	sort(candidates.begin(), candidates.end());
	BackTrace(result, v, candidates, target, target, 0);
	
	return result;
}
void BackTrace(vector<vector<int>> &result, vector<int> &v, vector<int> candidates,
	int target, int remain, int begin)
{
	if (remain < 0)
		return;
	else if (remain == 0)
		result.push_back(v);
	else
	{
		for (int i = begin; i < candidates.size(); ++i)
		{
			//以i-1开始的，包含i或者不包含i的都计算过了，所以避免重复，i就不用进行计算了
			if (i > begin && candidates[i] == candidates[i - 1])
				continue;
			v.push_back(candidates[i]);
			//通过i+1防止对同一元素重复提取，对candidates排序然后判断当前元素和上一元素防止重复计算。
			BackTrace(result, v, candidates, target, remain - candidates[i], i + 1);
			v.pop_back();
		}
	}
}

全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

vector<vector<int>> permute(vector<int>& nums)
{
	vector<vector<int>> result;
	if (nums.empty())
		return result;
	vector<int> v;
	dfs(nums,v,result);
	return result;
}
void dfs(const vector<int>& nums, vector<int> &v, vector<vector<int>> &result)
{
	//收敛条件
	if (v.size() == nums.size())
	{
		result.push_back(v);
		return;
	}
	for (auto i : nums)
	{
		//查找i是否在v中出现过
		auto pos = find(v.begin(), v.end(), i);
		if (pos == v.end())
		{
			v.push_back(i);
			dfs(nums, v, result);
			v.pop_back();
		}
	}
}

全排列II

给定一个可包含重复数字的序列，返回所有不重复的全排列。

输入: [1,1,2]
输出:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

void permuteUnique(vector<vector<int>> &result,
	vector<int> nums, int i);
vector<vector<int>> permuteUnique(vector<int> nums)
{
	vector<vector<int>> result;
	sort(nums.begin(), nums.end());
	permuteUnique(result, nums, 0);
	return result;
}
void permuteUnique(vector<vector<int>> &result,
	vector<int> nums, int i)
{
	if (i == nums.size() - 1)
	{
		result.push_back(nums);
		return;
	}
	for (int j = i; j < nums.size(); ++j)
	{
		//判断之前是否出现过该值
		if (j>i && nums[j]==nums[i])
			continue;
		else
		{
			swap(nums[i], nums[j]);
			permuteUnique(result, nums, i + 1);
		}
	}
}

子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

输入: nums = [1,2,3]
输出:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

思路：对于每一个元素，选择要或者是不要

vector<vector<int>> subsets(vector<int>& nums)
{
	vector<vector<int>> result;
	if (nums.size() < 1)
		return result;
	vector<int> v;
	int i = 0;
	subsetsCore(result, v, nums, i);
	return result;
}
void subsetsCore(vector<vector<int>> &result,vector<int> &v, vector<int>& nums,int i)
{
	if (i == nums.size())
	{
		result.push_back(v);
		return;
	}
	subsetsCore(result, v, nums, i + 1);
	v.push_back(nums[i]);
	subsetsCore(result, v, nums, i + 1);
	v.pop_back();
}

子集II

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

输入: [1,2,2]
输出:
[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

vector<vector<int>> subsetsWithDup(vector<int>& nums)
{
	sort(nums.begin(), nums.end());
	vector<vector<int>> result;
	vector<int> v;
	dfs(nums, 0, v, result);
	return result;
}
void dfs(const vector<int> &nums, int k, vector<int> &v, vector<vector<int>> &result)
{
	result.push_back(v);
	for (int i = k; i < nums.size(); ++i)
	{
		if (i != k && nums[i] == nums[i - 1])
			continue;
		v.push_back(nums[i]);
		dfs(nums, i + 1, v, result);
		v.pop_back();
	}
}

复原IP地址

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

示例:

输入: "25525511135"
输出: ["255.255.11.135", "255.255.111.35"]

vector<string> restoreIpAddresses(string s)
{
	vector<string> result;
	string ip;//存放中间结果
	dfs(s, 0, 0, ip, result);
	return result;
}
/*
s是原始数据，start是指从s的哪里开始，step是指ip地址是由4部分
组成
*/
void dfs(string s, int start, int step, string ip, vector<string> &result)
{
	if (start == s.size() && step == 4)
	{
		ip.resize(ip.size() - 1);
		result.push_back(ip);
		return;
	}
	//剩下的太长了
	if (s.size() - start > (4 - step) * 3)
		return;
	//剩下的太短了
	if (s.size() - start < (4 - step))
		return;
	int num = 0;
	for (int i = start; i < start + 3; ++i)
	{
		num = num * 10 + (s[i] - '0');
		if (num <= 255)
		{
			ip += s[i];
			dfs(s, i + 1, step + 1, ip + '.', result);
		}
		//比如：010010,可以是0.10.0.10，但不能是01.0.0.10
		if (num == 0)
			break;
	}
}

分割字符串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

vector<vector<string>> partition(string s)
{
	vector<vector<string>> result;
	vector<string> v;
	dfs(result, v, s, 0);
	return result;
}
void dfs(vector<vector<string>> &result, vector<string> &v,
	string s, int m)
{
	if (m == s.size())
	{
		result.push_back(v);
		return;
	}
	for (int i = m; i < s.size(); ++i)
	{
		if (isPail(s.substr(m, i - m + 1)))
		{
			//从m到i是回文
			v.push_back(s.substr(m, i - m + 1));
			//判断从i+1及其之后的是否是回文
			dfs(result, v, s, i + 1);
			//加入就要弹出，不影响下次判断
			v.pop_back();
		}
	}
}
bool isPail(string s)
{
	for (int i = 0; i < s.size() / 2; ++i)
		if (s[i] != s[s.size() - i - 1])
			return false;
	return true;
}