《剑指offer》算法题第十一天

今日题目：

1. 滑动窗口的最大值
2. 扑克牌中的顺子
3. 圆圈中最后剩下的数字
4. 求1+2+3+...+n
5. 不用加减乘除做加法
6. 构建乘积数组

今天的题目比较有意思，可以学到很多知识，包括第1题中的数据结构——双向队列，第3题约瑟夫环问题等。

 

1.滑动窗口的最大值

题目描述：
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路：
比较直接的方法是维护一个窗口，然后对于每个窗口找出当前窗口的最大值。这种方法的时间复杂度为O(kn)其中k为窗口大小。
另外一种方法是，利用队列，在队列中放置有可能为最大值的对象，将当前的最大值放在队首，这样就可以在O(1)的时间内得到最大值，这需要用到双向队列。

代码如下：

/**
用一个双端队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次
1.判断当前最大值是否过期
2.新增加的值从队尾开始比较，把所有比他小的值丢掉
*/
import java.util.ArrayDeque;
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size)
    {
        ArrayList<Integer> res = new ArrayList();
        if(size == 0) return res;
        
        ArrayDeque<Integer> queue = new ArrayDeque();
        int begin = 0;
        for(int i = 0; i < num.length; i++){
            begin = i - size + 1;
            if(queue.isEmpty())
                queue.add(i);
            else if(begin > queue.peekFirst())
                queue.pollFirst();
            
            while(!queue.isEmpty() && num[queue.peekLast()] <= num[i])
                queue.pollLast();
            queue.add(i);
            
            if(begin >= 0)
                res.add(num[queue.peekFirst()]);
        }
        return res;
        
    }
}

 

 

2. 扑克牌中的顺子

题目描述：
从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2~10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为0，可以看成任意数字。

思路：
比较直接，由于0可以代替任何数字，我们先把数组排序一下，然后计算0的个数，最后判断0的个数是否大于不连续的数字间隔数。

代码如下：

import java.util.*;
public class Solution {
    public boolean isContinuous(int [] nums) {
        if(nums.length == 0)
            return false;
        Arrays.sort(nums);
        int count_zero = 0;
        int count_no_con = 0;
        for(int i = 0; i < nums.length-1; i++){
            if(nums[i] == 0)
                count_zero++;
            else if(nums[i+1]==nums[i])
                return false;
            else{
                if(nums[i+1]-nums[i] > 1){
                    count_no_con += (nums[i+1]-nums[i]-1);
                }
            }
        }
        return count_zero >= count_no_con;
    }
}

 

 

3.圆圈中最后剩下的数字

题目描述：
0,1,2,...,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

思路：
这是有名的约瑟夫环问题，《剑指》中给出了两种解题方法：一种是用环形链表模拟圆圈；另一种是分析每次被删除的数字的规律并直接计算出圆圈中最后剩下的数字。
下面只贴出第二种算法，它是基于递归实现的，推导出递归方程的过程比较复杂，这边就不作阐述，感兴趣的朋友可参考：https://www.nowcoder.net/questionTerminal/f78a359491e64a50bce2d89cff857eb6

代码如下：

public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        if(n == 0) return -1;
        if(n == 1) return 0;
        return (LastRemaining_Solution(n-1,m)+m)%n;
    }
}

 

 

4. 求1+2+3+...+n

题目描述：
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

思路：
1. 运用数学公式 (1+n)*n/2
2. 递归，递归出口利用且（&&）运算的短路特性。

代码如下：

//利用且(&&)运算的短路特性
public class Solution {
    public int Sum_Solution(int n) {
        int sum = n;
        boolean ans = (n > 0) && (sum += Sum_Solution(n-1))>0;
        return sum;
    }
}

 

 

5. 不用加减乘除做加法

题目描述：
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

思路：
利用位运算来模拟加法运算，先做不进位的加法（异或），再算出进位（与，左移一位），然后再做和与进位的加法。其实这是一个递归的思想。

代码如下：

public class Solution {
    public int Add(int num1,int num2) {
        int sum = 0;
        int carry = 0;
        do{
            sum = (num1 ^ num2);
            carry = (num1 & num2) << 1;
            num1 = sum;
            num2 = carry;
        }while(carry != 0);
        return num1;
    }
}

 

 

6. 构建乘积数组

 

题目描述：
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。

思路：
一种比较直接的思路是用double loop来构建乘积数组，简单，但是时间复杂度为O(n2)。
另一种解决方法是将A[0]*A[1]*...*A[i-1]以及A[i+1]*...*A[n-1]分别存起来，最后再进行整合。

代码如下：

import java.util.ArrayList;
public class Solution {
    public int[] multiply(int[] A) {
        int n = A.length;
        int[] left = new int[n];
        int[] right = new int[n];
        left[0] = 1;
        for(int i = 1; i < n; i++){
            left[i] = left[i-1]*A[i-1];
        }
        right[n-1] = 1;
        for(int i = n-2; i >= 0; i--){
            right[i] = right[i+1]*A[i+1];
        }
        int[] B = new int[n];
        for(int i = 0; i < n; i++){
            B[i] = 1;
            B[i] = left[i]*right[i];
        }
        return B;
    }
}