比赛地址：数组
https://lingkou.com/contest/weekly-contest-102优化
905. 按奇偶校验排序数组ui
905. Sort Array By Parityspa
给定一个非负整数数组 A，返回一个由 A 的全部偶数元素组成的数组，后面跟 A 的全部奇数元素。code
你能够返回知足此条件的任何数组做为答案。blog
示例：排序
输入：[3,1,2,4] 输出：[2,4,3,1] 输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。
提示：队列
1 <= A.length <= 50000 <= A[i] <= 5000
题解：排序便可，时间o(N*logN)。本题的最优方案是时间o(N)空间o(1)get
/**
* @param {number[]} A
* @return {number[]}
*/
var sortArrayByParity = function(A) {
return A.sort((a,b)=>(a%2-b%2));
};
904. 水果成篮it
904. Fruit Into Baskets
在一排树中，第 i 棵树产生 tree[i] 型的水果。
你能够从你选择的任何树开始，而后重复执行如下步骤：
- 把这棵树上的水果放进你的篮子里。若是你作不到，就停下来。
- 移动到当前树右侧的下一棵树。若是右边没有树，就停下来。
请注意，在选择一颗树后，你没有任何选择：你必须执行步骤 1，而后执行步骤 2，而后返回步骤 1，而后执行步骤 2，依此类推，直至中止。
你有两个篮子，每一个篮子能够携带任何数量的水果，但你但愿每一个篮子只携带一种类型的水果。
用这个程序你能收集的水果总量是多少？
示例 1：
输入：[1,2,1] 输出：3 解释：咱们能够收集 [1,2,1]。
示例 2：
输入：[0,1,2,2] 输出：3 解释：咱们能够收集 [1,2,2]. 若是咱们从第一棵树开始，咱们将只能收集到 [0, 1]。
示例 3：
输入：[1,2,3,2,2] 输出：4 解释：咱们能够收集 [2,3,2,2]. 若是咱们从第一棵树开始，咱们将只能收集到 [1, 2]。
示例 4：
输入：[3,3,3,1,2,1,1,2,3,3,4] 输出：5 解释：咱们能够收集 [1,2,1,1,2]. 若是咱们从第一棵树或第八棵树开始，咱们将只能收集到 4 个水果。
提示：
1 <= tree.length <= 400000 <= tree[i] < tree.length
题解：维护一个长度为2的队列，遍历和上一棵树不同时入队，而且若是该树不在队列中时刷新选择第一棵树的位置为下一棵树。
/**
* @param {number[]} tree
* @return {number}
*/
var totalFruit = function(tree) {
var ans = 0;
var first = 0;
var q = [0];
for (var i = 1; i<= tree.length; i++) {
if (tree[i] != tree[i - 1]) {
ans = Math.max(ans, i - first);
q.push(i);
if (q.length > 2) {
if (tree[i] != tree[q[0]]) {
first = q[1];
}
q.shift();
}
}
}
return ans;
};
907. 子数组的最小值之和
907. Sum of Subarray Minimums
给定一个整数数组 A，找到 min(B) 的总和，其中 B 的范围为 A 的每一个（连续）子数组。
因为答案可能很大，所以返回答案模 10^9 + 7。
示例：
输入：[3,1,2,4] 输出：17 解释： 子数组为 [3]，[1]，[2]，[4]，[3,1]，[1,2]，[2,4]，[3,1,2]，[1,2,4]，[3,1,2,4]。 最小值为 3，1，2，4，1，1，2，1，1，1，和为 17。
提示：
1 <= A <= 300001 <= A[i] <= 30000
题解：首先是一个暴力方案。i为起点j为终点的子数组最小值为minn。
/**
* @param {number[]} A
* @return {number}
*/
var sumSubarrayMins = function(A) {
var m = 1e9 + 7;
var ans = 0;
var st = [];
for (var i = 0; i < A.length; i++) {
var minn = A[i];
for (var j = i; j < A.length; j++) {
minn = Math.min(minn, A[j]);
ans = (ans + minn) % m;
}
}
return ans;
};
以上o(N^2)显然超时了，考虑优化方案：用一个队列记录原数组中的递增序列的下标，依次遍历，以当前节点为最后一个元素的全部子数组的最小值累加。例如示例中[3,1,2,4]：
i=0，q=[-1,0]，ans+=3；以3为最后一个元素的子数组只有一个[3]
i=1，q=[-1,1]，ans+=A[1]*(q[1]-q[0])=1*2；以1为最后一个元素的子数组有[3,1]、[1]
i=2，q=[-1,1,2]，ans+=A[1]*(q[1]-q[0])+A[2]*(q[2]-q[1])；以2为最后一个元素的子数组有[3,1,2]、[1,2]、[2]，其中最小值是1的数组有两个，最小值是2的数组有1个
i=3，q=[-1,1,2,3]，ans+=A[1]*(q[1]-q[0])+A[2]*(q[2]-q[1])+A[3]*(q[3]-q[2])；以此类推
/**
* @param {number[]} A
* @return {number}
*/
var sumSubarrayMins = function(A) {
var m = 1e9 + 7;
var ans = 0;
var q = [-1];
for (var i = 0; i < A.length; i++) {
while(q.length > 1 && A[q[q.length - 1]] >= A[i]) {
q.pop();
}
q.push(i);
for (var j = 1; j < q.length; j++) {
ans = (ans + A[q[j]] * (q[j] - q[j - 1])) % m;
}
}
return ans;
};
上面方案能够经过，可是耗时3秒多。不使人满意，考虑一种方案。遍历数组时若是以当前值为子数组的最小值，那么这些子数组的个数是左边比该数字大的个数乘以右边的比该数字大的个数。为了得到左右两边的个数，须要用到两个辅助数组：prev[i]表明上一个不小于A[i]的位置、next[i]表明下一个大于A[i]的位置，详见代码。
/**
* @param {number[]} A
* @return {number}
*/
var sumSubarrayMins = function(A) {
var m = 1e9 + 7;
var ans = 0;
var q = [-1];
var prev = [];
for (var i = 0; i < A.length; i++) {
while(q.length > 1 && A[q[q.length - 1]] >= A[i]) {
q.pop();
}
prev[i] = q[q.length - 1];
q.push(i);
}
q = [A.length];
var next = new Array(A.length);
for (var i = A.length - 1; i >= 0; i--) {
while(q.length > 1 && A[q[q.length - 1]] > A[i]) {
q.pop();
}
next[i] = q[q.length - 1];
q.push(i);
}
for (var i = 0; i < A.length; i++) {
ans = (ans + A[i] * (i - prev[i]) * (next[i] - i)) % m;
}
return ans;
};