3-Sum问题

ThreeSum程序，统计一个文件或者数组里面所有和为0的三整数元组的数量（假设整数不会溢出）。

暴力解法

一个计时程序

此程序用来在进行算法分析时，计算一段程序的运行时间，单位为秒。

package com.li.algorithm.analyse;

/*算法分析时，计算一段程序的运行时间，单位为秒*/

public class StopWatch {
    private long start;

    public StopWatch() {
        start=System.currentTimeMillis();
    }

    public double elapsedTime() {
        long now=System.currentTimeMillis();
        return (now-start)/1000.0;
    }
}

暴力程序

3—Sum的暴力解法：直接使用三重循环。

package com.li.algorithm.analyse;

import java.util.Arrays;

import com.li.base.BinarySearch;
import com.li.stdlib.In;

public class ThreeSum {

    // 为数组赋值（使用随机数），有正有负
    public static void assign(int[] a) {
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 100 - 50);
        }
    }

    // 统计和为0的三整数元组的数目
    public static long count(int[] a) {
        int N = a.length;
        long cnt = 0L;
        for (int i = 0; i < N; i++)
            for (int j = i + 1; j < N; j++)
                for (int k = j + 1; k < N; k++)
                    if (a[i] + a[j] + a[k] == 0) {
                        cnt++;
                    }
        return cnt;
    }

    public static void main(String[] args) {
        int[] a = new int[6000];
        assign(a);

        StopWatch time1 = new StopWatch();
        System.out.println("总和：" + count(a));
        System.out.println("Time："+time1.elapsedTime()+"秒");
    }

}

运行结果：

总和：276631193
Time：23.073秒

经过多次运行测试，对于6000规模的数据，运行时间总在20秒以上。

算法分析

ThreeSum（在N个数中找出三个和为零的整数元组的数量）的运行时间的增长数量级为 N3 N 3 。

3-sum的成本模型：在研究解决3-sum问题的算法时，我们记录的是数组的访问次数（访问数组的次数，无论读写）

命题：3-sum的暴力算法使用了约 N3/2 N 3 / 2 次数数组访问来计算结果数量。

证明：从数组中取3个不同元素的组合为 c(N,3) c ( N , 3 ) ，也就是说该算法访问了约为 N3/6 N 3 / 6 个整数三元组中的所有 3 3 个整数

快速解法

在解决这个问题之前，我们可以先考虑一个简化的问题：2-sum，显而易见，这是统计一个文件或者数组里面所有和为0的二整数元组的数量（假设整数不会溢出）。

2-sum

我们在遍历的第一重循环中，确定了一个位置的元素，第二重循环中实际上就是去数组中找第一重循环中的元素的相反数，暴力地去寻找未免效率太低，我们可以使用二分查找，二分查找那么首先得排序。如下：

先给出二分查找算法的程序，数组事先已经排序（升序），找到则返回位置索引值，未找到则返回-1：

public static int rank(int key, int[] a){
    int low=0;
    int high=a.length-1;
    while(low<=high){
        int mid=(low+high)/2;
        if(key<a[mid]){
            high=mid-1;
        }
        else if(key>a[mid]){
            low=mid+1;
        }
        else{
            return mid;
        }
    }
    return -1;
}

利用二分搜索查找元组，if条件覆盖了三种情况：

• 如果二分查找找不到则返回-1，计数器不加一

• 如果二分查找返回的 j>i j > i ，那我们就有 a[i]+a[j]=0 a [ i ] + a [ j ] = 0 ，计数器加一

• 如果二分查找返回的 j j 在0和 i i 之间，也会有 a[i]+a[j]=0 a [ i ] + a [ j ] = 0 ，但是已经重复计算，计数器不能加一

public static long fastCount(int[] a){
    Arrays.sort(a);
    int N=a.length;
    long cnt=0L;
    for(int i=0; i<N; i++)
        if(BinarySearch.rank(-a[i], a)>i)
            cnt++;
    return cnt;
}

3-sum

借助同样的算法，我们可以得到比暴力解法快很多倍的算法，特别是数量规模大的时候。

package com.li.algorithm.analyse;

import java.util.Arrays;

import com.li.base.BinarySearch;
import com.li.stdlib.In;

public class ThreeSum {

    // 为数组赋值（使用随机数），有正有负
    public static void assign(int[] a) {
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 100 - 50);
        }
    }

    //统计的fast版本算法：基于二分查找
    public static long fastCount(int[] a) {
        //先排序
        Arrays.sort(a);
        int N=a.length;
        long cnt=0L;
        for(int i=0; i<N; i++)
            for(int j=i+1; j<N; j++)
                if(BinarySearch.rank(-a[i]-a[j], a)>j)
                    cnt++;
        return cnt;
    }


    public static void main(String[] args) {
        int[] a = new int[6000];
        assign(a);

        StopWatch time2 = new StopWatch();
        System.out.println("总和：" + fastCount(a));
        System.out.println("Time："+time2.elapsedTime()+"秒");
    }

}

运行结果：

总和：4497343
Time：0.234秒

多次运行我们能够发现，时间基本上在0.25秒左右，比暴力解法快许多倍。

算法复杂度

二分查找的算法复杂度是 lgN lg ⁡ N ，所以上述算法的算法复杂度为 N2lgN N 2 lg ⁡ N

倍率定理

倍率定理：

如果

T(N)∼aNblgN T ( N ) ∼ a N b lg ⁡ N

那么

T(2N)/T(N)∼2b T ( 2 N ) / T ( N ) ∼ 2 b

证明：略，简单的数学证明

由此我们可以根据已有数据估算 3-sum 算法的 N N 规模时的执行时间：倍率为4

一下是我利用3-sum的快速查找算法做的实验（N：代表数据规模；Time：执行时间，单位为秒；Multiple：与上一次实验的倍数）

随着规模的越大，实验的结果越符合我们的定理预计。