[princeton/Algotithm I/week1]（5）Interview Questions: Analysis of Algorithms

Interview Questions: Analysis of Algorithms

《算法4》这本书提供的TwoSumFast解法为NlogN，ThreeSumFast解法为N2logN，根据课后练习，要实现3Sum复杂度为N2，建议先把2Sum复杂度实现为N。同时教材提示用排好序的数组可以实现复杂度N。没有发现排好序的数组对复杂度降至N有太大帮助，于是在网上搜索了下大家的做法。网上的大部分都是建议用set或map来做，这里采用map，代码如下：

import java.util.Arrays;
import java.util.HashMap;

public class ThreeSumQuadratic {
    public static int count(int[] a, int target) {
        Arrays.sort(a);// 数组从小到大排序，后面要使用有序数组的性质简化运算
        System.out.println(Arrays.toString(a));
        System.out.println("target="+target);
        int cnt = 0;
        int n = a.length;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            map.put(a[i], i); //以数组value为key，index为map值
        }
        for (int i = 0; i < n - 1; i++) {//i不会超过n-2
            for (int j = i + 1; j < n; j++) {//j从i+1开始统计，不会超过n-1
                int smallValue = a[i] + a[j]; //因为排好序了，所以最开始的a[i]+a[j]
                if (smallValue > target) //当a[i]+a[j]>target时没必要计算了，因为后续的查找就会重复
                    break;
                int bigValue = target-smallValue; //计算出对应的数值较大的value
                Integer bigIndex = map.get(bigValue); //查找数值较大的value所在的位置
                if (bigIndex != null && bigIndex > i && bigIndex > j) {
                    System.out.println(
                            "[" + i + "]=" + a[i] + ",[" + j + "]" + a[j] + ",[" + bigIndex + "]" + (bigValue));
                    cnt++;
                }
            }
        }
        return cnt;
    }

    public static void main(String[] args) {
        int[] a = { 30, -40, -20, -10, 40, 0, 10, 5 };        
        System.out.println(count(a,0));
    }
}

问题描述: 这是关于双调数组搜索的问题，所谓的双调数组的特点是，数组元素先递增，再递减，类似于一个峰的形式。然后标准实现方法的最坏情况是~3lgn的比较次数，然后最好的实现方法的最坏情况比较次数是关于~2lgn的。

解决方案: 这里的标准解决方法很好实现，先使用二分法的变式找到数组的最大值，然后左右分别进行二分查找即可，很容易得到~3lgn的比较次数。对于更有效率的查找方式，这里我选择不查找最大值。具体的d递归实现方式描述如下：

先找到mid，将其与key比较，如果相等则返回true，否则进行下一步；
将mid值和左右两个值进行比较，判断mid在山峰的左边还是右边亦或是峰顶；
如果是峰顶，直接采取左右两边二分查找；如果是峰左，那么判定key值与mid值的相对大小，如果key值大于mid值，那么可以知道key值位于mid的右边，直接递归bitonicSearch(mid+1, hi, key)即可；如果key值小于mid值，那么需要对左边进行二分查找以及对右边进行递归查找；对于mid位于峰右的情况是同理的。

public class Bitonic {
    private int[] bArray;
    private int size;

    public Bitonic(final int[] arr) {
        size = arr.length;
        bArray = new int[size];
        for (int i = 0; i < size; i++) {
            bArray[i] = arr[i];
        }
    }

    public boolean search(int low, int hi, int key) {
        int mid = low + (hi - low) / 2;
        if (bArray[mid] == key) {
            return true;
        }
        if (mid == 0) {
            return search(mid + 1, hi, key);
        } else if (mid == size - 1) {
            return search(low, mid - 1, key);
        } else {
            if (bArray[mid - 1] < bArray[mid] && bArray[mid] > bArray[mid + 1]) {   // mid
                return bArray[mid] < key ? false :((BinarySearch.indexOf(bArray, low, mid - 1, key) != -1)
                        || (BinarySearch.indexOfReverse(bArray, mid + 1, hi, key) != -1));
            } else if (bArray[mid - 1] < bArray[mid]) {    //left
                return bArray[mid] < key ? search(mid + 1, hi, key) :
                    ((BinarySearch.indexOf(bArray, low, mid - 1, key) != -1) || search(mid + 1, hi, key));
            } else {    //right
                return bArray[mid] < key ? search(low, mid - 1, key) :
                    ((BinarySearch.indexOf(bArray, mid + 1, hi, key) != -1) || search(low, mid - 1, key));
            }
        } 
    }

 

问题描述: 这个是关于爬楼扔鸡蛋确定安全楼层的问题。

解决方案: 其实这个就是解决两个子问题进行递归的问题，分别是鸡蛋碎了和鸡蛋没碎两种情况，而这两种情况也分别对应了确定的不安全楼层和安全楼层。

参考blog：Coursera Algorithms week1 算法分析 练习测验: Egg drop 扔鸡蛋问题