题目## 题目
#描述
这是一篇针对初学者的题解。共用两种方法解决。从暴力算法一步步到最优算法。
知识点：数组，队列
难度：二星
#题解
题目描述：给定一个数组num和一个窗口大小size，求每个窗口的最大值。
##方法一：暴力方法
根据题目描述，我们很容易想到暴力方法。并且也很轻松的就可以写出来。如果数组的大小是n，窗口的大小是size，那么窗口的数量就是 n - size + 1.
算法步骤如下：
- 枚举每个窗口的左边界 i
- 根据窗口的左边界i可以对应计算出右边界j
- 遍历窗口，计算出最大值
代码如下：
class Solution {
public:
vector<int> maxInWindows(const vector<int>& num, unsigned int size)
{
vector<int> ret;
if (num.size() == 0 || size < 1 || num.size() < size) return ret;
int n = num.size();
for (int i = 0; i + size - 1 < n; ++i) {
int j = i + size - 1;
int max_val = num[j];
for (int k = i; k < j; ++k) {
max_val = max(max_val, num[k]);
}
ret.push_back(max_val);
}
return ret;
}
};
时间复杂度：O(n*k), 其中n为数组大小，k为窗口大小
空间复杂度：O(1)，存结果必须要开的数组不算入额外空间
##方法二：单调队列
方法一种存在很多大量重复计算，比如说，对于数组，假设我们当前遍历到下标i，对于下标i+1的元素（假设i和i+1都在同一个窗口），如果比arr[i]大，说明了什么？
如果arr[i+1] 已经大于了 arr[i], 那么还要arr[i]有什么用.就有点“既生瑜何生亮”的感觉。
如果arr[i+1] < arr[i]呢？显然arr[i]还是需要保留的。为什么呢？
因为又可以arr[i] 对于下一个arr[i+1]所在的窗口来说，arr[i]已经失效了。
假设这里有那么一个容器可以保留上述操作。
- 遍历数组的每一个元素，
- 如果容器为空，则直接将当前元素加入到容器中。
- 如果容器不为空，则让当前元素和容器的最后一个元素比较，如果大于，则将容器的最后一个元素删除，然后继续讲当前元素和容器的最后一个元素比较
- 如果当前元素小于容器的最后一个元素，则直接将当前元素加入到容器的末尾
- 如果容器头部的元素已经不属于当前窗口的边界，则应该将头部元素删除
总结一下，首先容器中放的元素应该是单调递减的。然后还有删除容器头部元素和最后一个元素的操作。因此，这样的数据结构就是双端队列。c++中就是deque
如何判断队列中头部的元素是否过期呢？
这里我们可以存数组的下标，根据下标的比较来判断。比如，当前遍历到下标为5的元素，窗口的大小为3， 显然显然下标为2的已经过期了。
代码如下：
class Solution {
public:
vector<int> maxInWindows(const vector<int>& num, unsigned int size)
{
vector<int> ret;
if (num.size() == 0 || size < 1 || num.size() < size) return ret;
int n = num.size();
deque<int> dq;
for (int i = 0; i < n; ++i) {
while (!dq.empty() && num[dq.back()] < num[i]) {
dq.pop_back();
}
dq.push_back(i);
// 判断队列的头部的下标是否过期
if (dq.front() + size <= i) {
dq.pop_front();
}
// 判断是否形成了窗口
if (i + 1 >= size) {
ret.push_back(num[dq.front()]);
}
}
return ret;
}
};
时间复杂度：O(n), 其中n为数组大小
空间复杂度：O(k)，k为窗口的大小
题目主要信息:
- 给定一个数组，求这组数字的全排列
- 数组无重复元素
- 以数字在数组中的位置靠前为优先级，按字典序排列输出
举一反三：
学习完本题的思路你可以解决如下题目：
递归+回溯（推荐使用）
知识点：递归与回溯
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
如果是线型递归，子问题直接回到父问题不需要回溯，但是如果是树型递归，父问题有很多分支，我需要从子问题回到父问题，进入另一个子问题。因此回溯是指在递归过程中，从某一分支的子问题回到父问题进入父问题的另一子问题分支，因为有时候进入第一个子问题的时候修改过一些变量，因此回溯的时候会要求改回父问题时的样子才能进入第二子问题分支。
思路：
全排列就是对数组元素交换位置，使每一种排列都可能出现。因为题目要求按照字典序排列输出，那毫无疑问第一个排列就是数组的升序排列，它的字典序最小，后续每个元素与它后面的元素交换一次位置就是一种排列情况，但是如果要保持原来的位置不变，那就不应该从它后面的元素开始交换而是从自己开始交换才能保证原来的位置不变，不会漏情况。
如何保证每个元素能和从自己开始后的每个元素都交换位置，这种时候我们可以考虑递归。为什么可以使用递归？我们可以看数组[1,2,3,4]，如果遍历经过一个元素2以后，那就相当于我们确定了数组到该元素为止的前半部分，前半部分1和2的位置都不用变了，只需要对3，4进行排列，这对于后半部分而言同样是一个全排列，同样要对从每个元素开始往后交换位置，因此后面部分就是一个子问题。那我们考虑递归的几个条件：
- 终止条件： 要交换位置的下标到了数组末尾，没有可交换的了，那这就构成了一个排列情况，可以加入输出数组。
- 返回值： 每一级的子问题应该把什么东西传递给父问题呢，这个题中我们是交换数组元素位置，前面已经确定好位置的元素就是我们返还给父问题的结果，后续递归下去会逐渐把整个数组位置都确定，形成一种排列情况。
- 本级任务： 每一级需要做的就是遍历从它开始的后续元素，每一级就与它交换一次位置。
如果只是使用递归，我们会发现，上例中的1与3交换位置以后，如果2再与4交换位置的时候，我们只能得到3412这种排列，无法得到1432这种情况。这是因为遍历的时候1与3交换位置在2与4交换位置前面，递归过程中就默认将后者看成了前者的子问题，但是其实我们1与3没有交换位置的情况都没有结束，相当于上述图示中只进行了第一个分支。因此我们用到了回溯。处理完1与3交换位置的子问题以后，我们再将其交换回原来的情况，相当于上述图示回到了父节点，那后续完整的情况交换我们也能得到。
//遍历后续的元素
for(int i = index; i < num.size(); i++){
//交换二者
swap(num, i, index);
//继续往后找
recursion(res, num, index + 1);
//回溯
swap(num, i, index);
}
具体做法：
- step 1：先将数组排序，获取字典序最小的排列情况。
- step 2：递归的时候根据当前下标，遍历后续的元素，交换二者位置后，进入下一层递归。
- step 3：处理完一分支的递归后，将交换的情况再换回来进行回溯，进入其他分支。
- step 4：当前下标到达数组末尾就是一种排列情况。
图示：
Java实现代码：
import java.util.*;
public class Solution {
//交换位置函数
private void swap(ArrayList<Integer> num, int i1, int i2{
int temp = num.get(i1);
num.set(i1, num.get(i2));
num.set(i2, temp);
}
public void recursion(ArrayList<ArrayList<Integer>> res, ArrayList<Integer> num, int index){
//分枝进入结尾，找到一种排列
if(index == num.size() - 1){
res.add(num);
}
else{
//遍历后续的元素
for(int i = index; i < num.size(); i++){
//交换二者
swap(num, i, index);
//继续往后找
recursion(res, num, index + 1);
//回溯
swap(num, i, index);
}
}
}
public ArrayList<ArrayList<Integer>> permute(int[] num) {
//先按字典序排序
Arrays.sort(num);
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> nums = new ArrayList<Integer>();
//数组转ArrayList
for(int i = 0; i < num.length; i++)
nums.add(num[i]);
recursion(res, nums, 0);
return res;
}
}
C++实现代码：
class Solution {
public:
void recursion(vector<vector<int> > &res, vector<int> &num, int index){
//分枝进入结尾，找到一种排列
if(index == num.size() - 1)
res.push_back(num);
else{
//遍历后续的元素
for(int i = index; i < num.size(); i++){
//交换二者
swap(num[i], num[index]);
//继续往后找
recursion(res, num, index + 1);
//回溯
swap(num[i], num[index]);
}
}
}
vector<vector<int> > permute(vector<int> &num) {
//先按字典序排序
sort(num.begin(), num.end());
vector<vector<int> > res;
//递归获取
recursion(res, num, 0);
return res;
}
};
Python实现代码：
class Solution:
def recursion(self, res:List[List[int]], num:List[int], index:int):
#分枝进入结尾，找到一种排列
if index == len(num) - 1:
res.append(num)
else:
#遍历后续的元素
for i in range(index, len(num)):
#交换二者
temp = num[i]
num[i] = num[index]
num[index] = temp
#继续往后找
self.recursion(res, num, index + 1)
#回溯
temp = num[i]
num[i] = num[index]
num[index] = temp
def permute(self , num: List[int]) -> List[List[int]]:
#先按字典序排序
num.sort()
res = list(list())
#递归获取
self.recursion(res, num, 0)
return res
复杂度分析：
- 时间复杂度： O ( n ∗ n ! ) O(n*n!) O(n∗n!)，n个元素的数组进行全排列的递归，每次递归都要遍历数组
- 空间复杂度： O ( n ) O(n) O(n)，递归栈的最大深度为数组长度n，res属于返回必要空间
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
