每周算法七

1.买卖股票的最佳时机 II

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
  let res=0;
  for(let i=0;i<prices.length-1;i++){
    if(prices[i]<prices[i+1]){
      res+=prices[i+1]-prices[i]
    }
  }
  return res
};

2. 判断子序列

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isSubsequence = function(s, t) {
  let L=0;
  let R=0;
  while(R<t.length){
    if(s[L]==t[R]){
      L++
    }
    R++
  }
  if(L===s.length){
    return true
  }
  return false
};

3.移除元素

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
  let index = nums.indexOf(val)
  while(index!=-1){
    nums.splice(index,1)
    index = nums.indexOf(val)
  }
  return nums.length
};

4.移除元素

• 二分查找

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
  let len = nums.length
  if(len===0) return -1
  if(len==1) return nums[0]===target?0:-1
  let l = 0,r=len-1;
  while(l<=r){
    let mid = Math.floor((l+r)/2)
    if(nums[mid]===target){
      return mid;
      // break;
    }
    if(nums[0]<=nums[mid]){
      if(nums[0]<=target&&target<=nums[mid]){
         r=mid-1
      }else{
        l=mid+1
      }
    }else{
      if(nums[mid]<=target&&target<=nums[len-1]){
        l=mid+1
      }else{
        r=mid-1
      }
    }
  }
  if(l>r){
    return -1;
  }
};

5.在排序数组中查找元素的第一个和最后一个位置

• 二分查找

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function (nums, target) {
  let len = nums.length
  let l = 0,
    r = len - 1
  while (l <= r) {
    let mid = Math.floor((l + r) / 2)
    if (nums[mid] === target) {
      l = mid
      r = mid
      break;
    }
    if (target < nums[mid]) {
      r = mid - 1;
    } else {
      l = mid + 1;
    }
  }
  if (l > r) {
    return [-1, -1]
  } else {
    while (nums[l-1] === target) l--
    while (nums[r+1] === target) r++
    return [l, r]
  }
};

6.搜索插入位置

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
  let index = nums.indexOf(target)
  if(index!=-1){
    return index
  }else{
    for(let i=0;i<nums.length;i++){
      if(target<nums[i]){
        return i
      }
    }
    return nums.length
  }
};

7.组合总和

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
  let res = []
  const dfs = (start,temp,sum)=>{
    if(sum>target){
      return
    }
    if(sum===target){
      res.push(temp.slice())
      return
    }
    for(let i=start;i<candidates.length;i++){
      temp.push(candidates[i])
      dfs(i,temp,sum+candidates[i])
      temp.pop()
    }
  }
  dfs(0,[],0)
  return res
};

8.组合总和Ⅱ

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum2 = function(candidates, target) {
    let res =[]
    // 首先把给candidates排序，让其相同的元素都挨在一起。 
    candidates.sort((a,b)=>a-b)
    const dfs=(start,temp,sum)=>{
      if(sum>target){
        return
      }
      if(sum===target){
        res.push(temp.slice())
        return
      }
      for(let i=start;i<candidates.length;i++){
        // 同一层去重
        if(i>start&&candidates[i]===candidates[i-1]){
          continue;
        }
        temp.push(candidates[i])
        // 这里i+1是指用过i就不需要用i了
        dfs(i+1,temp,sum+candidates[i])
        temp.pop()
      }
    }
    dfs(0,[],0)
    return res
};

9.全排列 II

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permuteUnique = function(nums) {
  let  res = []
  nums.sort((a,b)=>a-b)
  let used= new Array(nums.length).fill(false);
  const dfs = (temp,num)=>{
    if(num===nums.length){
      res.push(temp.slice())
      return
    }
    for(let i=0;i<nums.length;i++){
      if(used[i]||(i>0&&nums[i-1]===nums[i])&&!used[i-1]){
        continue;
      }
      temp.push(nums[i])
      used[i]=true
      dfs(temp,num+1)
      used[i]=false
      temp.pop()
    }
  }
  dfs([],0)
  return res
};

10.加一

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
  let len = digits.length-1
  if(digits[len]+1<10){
    digits[len] = digits[len]+1
    return digits
  }else{
    let n = len;
    digits[n] = (digits[n]+1)%10
    while(digits[n]===0){
      n--
      if(n<0) break
      digits[n] = (digits[n]+1)%10
    }
    if(n<0){
      digits.unshift(1)
    }
  }
  return digits;
};

11.最大子序和

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
  let sum = nums[0]
  let max = nums[0]
  for(let i=1;i<nums.length;i++){
    sum = sum+nums[i]>nums[i]?sum+nums[i]:nums[i]
    if(sum>max){
      max = sum
    }
  }
  return max
};

12.滑动窗口的最大值

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSlidingWindow = function(nums, k) {
  if(nums.length==0) return []
  let res = []
  let arr=[]
  for(let i=0;i<=nums.length-k;i++){
    for(let j=i;j<i+k;j++){
      arr.push(nums[j])
    }
    res.push(Math.max(...arr))
    arr = []
  }
  return res;
};

13.一维数组的动态和

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var runningSum = function(nums) {
  if(nums.length===0) return []
  let res=[]
  res.push(nums[0])
  for(let i=1;i<nums.length;i++){
    res.push(res[i-1]+nums[i])
  }
  return res;
};

14.螺旋矩阵

/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var spiralOrder = function(matrix) {
  if(matrix.length===0) return []
  let res = []
  let len1 = matrix.length,len2 = matrix[0].length

  const fun = (m,n,begin)=>{
    let k,x;
    if(res.length>=len1*len2){
      return
    }
    if(n===0) return;
    // console.log(m,n,begin,res)
    if((n<0)){
      return
    }
    k=begin,x=begin;
    if((m==1)){
      for(let i=0;i<n;i++){
        res.push(matrix[k][x]);
        x++;
      }
      return;
    }
    if((n==1)){
      for(let i=0;i<m;i++){
        res.push(matrix[k][x]);
        k++;
      }
      return;
    }
    for(let i=0;i<n-1;i++){
      res.push(matrix[k][x]);
      x++;
    }
    for(let i=0;i<m-1;i++){
      res.push(matrix[k][x]);
      k++;
    }
    for(let i=0;i<n-1;i++){
      res.push(matrix[k][x]);
      x--;
    }
    for(let i=0;i<m-1;i++){
      res.push(matrix[k][x]);
      k--;
    }
    fun(m-2,n-2,begin+1)
  }
  fun(len1,len2,0)
  return res;
};

15.螺旋矩阵 II

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function(n) {
  let res = [];
  for(let i=0;i<n;i++){
    res[i]=new Array();
  }
  let num=1
  const fun = (tn,begin)=>{
    let i,j;
    i=begin,j=begin;
    // console.log(tn,num,begin)
    if(tn==1){
      res[begin][begin] = num++;
      return
    }
    if(num>=n*n){
      return
    }
   
    for(let k=0;k<tn-1;k++){
      res[i][j] = num++;
      j++;
    }
    for(let k=0;k<tn-1;k++){
      res[i][j] = num++;
      i++;
    }
    for(let k=0;k<tn-1;k++){
      res[i][j] = num++;
      j--;
    }
    for(let k=0;k<tn-1;k++){
      res[i][j] = num++;
      i--;
    }
    fun(tn-2,begin+1)
  }
  fun(n,0)
  return res
};

16.不同路径

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
  if(m===0 || n===0) return 0;
  let dp = []
  for(let i=0;i<m;i++){
    dp[i]=new Array()
  }
  for(let i=0;i<m;i++){
    for(let j=0;j<n;j++){
      if(i===0||j===0){
        dp[i][j] = 1;
      }else{
        dp[i][j] = dp[i-1][j]+dp[i][j-1]
      }
    }
  }
  return dp[m-1][n-1]
};