第10章 算法设计技巧

哈夫曼算法

算法对由树组成的一个森林进行。一棵树的权等于它的树叶的频率的和。任意选取最小权的两棵树T1和T2，并任意形成以T1和 T2为子树的新树，将这样的过程进行C - 1次。在算法的开始，存在C棵单节点树——每个字符一棵。在算法结束时得到一棵树，这棵树就是最优哈夫曼编码树。

10.1.3 近似装箱问题

联机算法：

每一件物品必须放入一个箱子之后才能处理下一件物品。

存在使得任意联机装箱算法至少使用4/3最优箱子数的输入。

脱机算法：

在一个脱机装箱算法中，我们做任何事都需要等到所有的输入数据全部读取之后才进行。

下项适合算法：

当处理任何一项物品时，我们检查看它是否还能装进刚刚装进物品的同一个箱子中去。如果能够装进去，那么就把它放入该箱中；否则，就开辟一个新的箱子。

令M是讲一列物品I装箱所需的最有装箱数，则下项适合算法所用箱数绝不超过2M个箱子。存在一些顺序使得下项适合算法用箱数达2M - 2个。

首次适合算法：

依序扫描这些箱子并把新的一项物品放入足能盛下它的第一个箱子中。

令M是将一列物品I装箱所需要的最优箱子数，则首次适合算法使用的箱子绝不多于17/10 M[向上取整]。存在使得首次适合算法使用17/10(M - 1)[向上取整]个箱子的序列。

最佳适合算法：

该算法不是把一项新物品放入所发现的第一个能容纳它的箱子，而是放到所有箱子中能够容纳它的最满的箱子中。

所有联机算法的主要问题在于将大项物品装箱困难，特别是当它们在输入的后期出现的时候。围绕这个问题的自然方法是将各项物品排序，把最大的物品放在最先。此时我们可以应用首次适合算法或最佳适合算法，分别得到首次适合递减算法和最佳适合递减算法。

10.2 分治算法

分（divide）：递归解决较小的问题（当然，基本情况除外）。

治（conque）：然后从子问题的解构建原问题的解。

10.2.2 最近点问题

min(&, dc)的精化计算

    /**
     * // Points are all in the strip and sorted by y-coordinate
     *
     * for(int i = 0; i < numPointsInStrip; i++)
     *      for(j = i + 1; j < numPointsInStrip; j++)
     *          if(pi and pj's y-coordinates differ by more than &)
     *              break;          // Go to next pi.
     *          else
     *          if(dist(pi, pj) < &)
     *              & = dist(pi, pj);
     */

我们将保留两个表。一个是按照x坐标排序的点的表，而另一个是按照y坐标排序的点的表。我们分别称这两个表为P和Q。这两个表可以通过一个预处理排序步骤花费O(NlogN)得到，因此并不影响时间界。PL和PL是传递给左半部分递归调用的参数表，PR和QR是传递给右半部分递归调用的参数表。我们已经看到，P很容易在中间分开。一旦分割线已知，我们依序转到Q，把每一个元素放入相应的QL或QR。容易看出，QL和QR将自动地按照y坐标排序。当递归调用返回时，我们扫描Q表并删除其x坐标不在带内的所有的点。此时Q只含有带中的点，而这些点保证是按照它们的y坐标排序的。

10.2.3 选择问题

五数中值取中分割法

1. 把N个元素分成N/5[向下取整]组5个元素的组，忽略剩余(最多4个)的元素。

2. 找出每组的中值项，得到N/5[向下取整]个中值项的表M。

3. 求出M的中值项，将其作为枢纽元v返回。

降低比较的平均次数：分治算法还可以用来降低选择算法所需要的期望比较次数。

整数相乘

XL*YR + XR*YL = (XL - XR)*(YR - YL) + XL*YL + XR*YR

矩阵乘法

简单的O(N^3)矩阵乘法

    /**
     * Standard matrix multiplication.
     * Arrays start at 0.
     * Assumes a and b are square.
     */
    public static int[][] multiply(int[][] a, int[][] b)
    {
        int n = a.length;
        int[][] c = new int[n][n];

        for (int i = 0; i < n; i++)         // Initialization
            for (int j = 0; j < n; j++)
                c[i][j] = 0;

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                for (int k = 0; k < n; k++)
                    c[i][j] += a[i][k] * b[k][j];

        return c;
    }

10.3 动态规划

任何数学递推公式都可以直接转换成递归算法，但是基本现实是编译器常常不能正确对待递归算法，结果导致低效的程序。当怀疑很可能是这种情况时，我们必须再给编译器提供一些帮助，将递归算法重新写成非递归算法，让后者把那些子问题的答案系统地记录在一个表内。利用这种方法的技巧叫作动态规划。

 

计算斐波那契数的低效算法

    public static int fib(int n)
    {
        if (n <= 1)
            return 1;
        else
            return fib(n - 1) + fib(n - 2);
    }

计算斐波那契数的线性算法

    public static int fibonacci(int n)
    {
        if (n <= 1)
            return 1;

        int last = 1;
        int nextToLast = 1;
        int answer = 1;

        for (int i = 2; i <= n; i++)
        {
            answer = last + nextToLast;
            nextToLast = last;
            last = answer;
        }
        return answer;
    }

计算C(N) = (2 / N)∑C(i) + N的值的递归方法

    public static double eval(int n)
    {
        if (n == 0)
            return 1.0;
        else
        {
            double sum = 0.0;
            for (int i = 0; i < n; i++)
                sum += eval(i);
            return 2.0 * sum / n + n;
        }
    }

使用一个表来计算C(N) = (2 / N)∑C(i) + N的值

    public static double eval1(int n)
    {
        double[] c = new double[n + 1];

        c[0] = 1.0;
        for (int i = 0; i <= n; i++)
        {
            double sum = 0.0;
            for (int j = 0; j < i; j++)
                sum += c[j];
            c[i] = 2.0 * sum / i + i;
        }
        return c[n];
    }

找出矩阵乘法最优顺序的程序

    /**
     * Compute optimal ordering of matrix multiplication.
     * c contains the number of columns for each of the n matrices.
     * c[0] is the number of rows in matrix 1.
     * The minimum number of multiplications is left in m[1][n].
     * Actual ordering is computed via another procedure using lastChange.
     * m and lastChange are indexed starting at 1, instead of 0.
     * Note: Entries below main diagonals of m and lastChange.
     * are meaningless and uninitialized.
     */
    public static void optMatrix(int[] c, long[][]m, int[][] lastChange)
    {
        int n = c.length - 1;

        for (int left = 1; left <= n; left++)
            m[left][left] = 0;
        for (int k = 1; k < n; k++)
            for (int left = 1; left <= n - k; left++)
            {
                // For each position
                int right = left + k;
                m[left][right] = INFINITY;
                for (int i = left; i < right; i++)
                {
                    long thisCost = m[left][i] + m[i + 1][right] + c[left - 1] * c[i] * c[right];
                    if (thisCost < m[left][right])          // Update min
                    {
                        m[left][right] = thisCost;
                        lastChange[left][right] = i;
                    }
                }
            }
    }

所有点对最短路径

    static int NOT_A_VERTEX = -1;
    /**
     * Compute all-shortest paths.
     * a[][] contains the adjacency matrix with
     * a[i][i] presumed to be zero.
     * d[] contains the values of the shortest path.
     * Vertices are numbered starting at 0; all arrays
     * have equal dimension. A negative cycle exists if
     * d[i][i] is set to a negative value.
     * Actual path can be computed using path[][].
     * NOT_A_VERTEX is -1
     */
    public static void allPairs(int[][] a, int[][] d, int[][] path)
    {
        int n = a.length - 1;

        // Initialize d and path
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                d[i][j] = a[i][j];
                path[i][j] = NOT_A_VERTEX;
            }

        for (int k = 0; k < n; k++)
            // Consider each vertex as an intermediate
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                    if (d[i][k] + d[k][j] < d[i][j])
                    {
                        // Update shortest path
                        d[i][j] = d[i][k] + d[k][j];
                        path[i][j] = k;
                    }
    }

 

不溢出的随机数发生器

// CONSTRUCTION: with (a) no initializer or (b) an integer
//      that specifies the initial state of the generator
//
// Return a random number according to some distribution:
// int randomInt()
// int random0_1()
// int randInt(int low, int high)
// long randomLong(long low, long high)
// void permute(Object[] a)

/**
 * Random number class, using a 31-bit
 * linear congruential generator.
 * Note that java.util contains a class Random
 * so watch out for name conflicts.
 * @author Mark Allen Weiss
 */
public class Random
{
    private static final int A = 48271;
    private static final int M = 2147483647;
    private static final int Q = M / A;
    private static final int R = M % A;

    /**
     * Construct this Random object with
     * initial state obtained from system clock.
     */
    public Random(){ this((int)(System.currentTimeMillis() % Integer.MAX_VALUE)); }

    /**
     * Construct this Random object with
     * specified initial state
     * @param initialValue the initial state
     */
    public Random(int initialValue)
    {
        if (initialValue < 0)
            initialValue += M;

        state = initialValue;
        if (state == 0)
            state = 1;
    }

    /**
     * Return a pseudorandom int, and change the
     * internal state
     * @return the pseudorandom int.
     */
    public int randomInt()
    {
        int tmpState = A * (state % Q) - R * (state / Q);
        if (tmpState > 0)
            state = tmpState;
        else
            state = tmpState + M;

        return state;
    }

    /**
     * Return a pseudorandom and change the
     * internal state: DOES NOT WORK.
     * @return the pseudorandom int.
     */
    public int randIntWRONG(){ return state = (A * state) % M; }

    /**
     * Return a pseudorandom double in the open 0..1
     * and change the internal state.
     * @return the pseudorandom double
     */
    public double random0_1(){ return (double) randomInt() / M; }

    /**
     * Return an int in the closed range [low, high], and
     * change the internal state.
     * @param low the minimum value returned
     * @param high the maximum value returned.
     * @return the pseudorandom int.
     */
    public int randomInt(int low, int high)
    {
        double partitionSize = (double) M / (high - low + 1);

        return (int)(randomInt() / partitionSize) + low;
    }

    /**
     * Random an long in the closed range[low,high], and
     * change the internal state
     * @param low the minimum value returned
     * @param high the maximum value returned
     * @return the pseudorandom long.
     */
    public long randomLong(long low, long high)
    {
        long longVal = ((long)randomInt() << 31) + randomInt();
        long longM = ((long) M  << 31) + M;

        double partitionSize = (double) longM / (high - low  + 1);
        return (long)(longVal / partitionSize) + low;
    }
    
    private int state;
}

48比特随机数发生器

/**
 * Random number class, using a 48-bit
 * linear congruential generator.
 */
public class Random48
{
    private static final long A = 25_214_903_917L;
    private static final long B = 48;
    private static final long C = 11;
    private static final long M = (1L<<B);
    private static final long MASK = M - 1;

    public Random48(){ state = System.nanoTime() & MASK; }

    public int randomInt() { return next(32); }

    public double random0_1()
    { return ((long)(next(26)) << 27) + next(27) / (double) (1L << 53); }

    /**
     * Return specified number of random bits
     * @param bits number of bits to return
     * @return specified random bits
     * @throws IllegalArgumentException if bits is more than 32
     */
    private int next(int bits)
    {
        if (bits <= 0 || bits > 32)
            throw new IllegalArgumentException();

        state = (A * state + C) & MASK;

        return (int) (state >>> (B - bits));
    }
    private long state;
}

10.4.3 素性测试

一种概率素性测试算法（伪码）

public class witness
{
    /**
     * Method that implements the basic primality test.
     * If witness does not return 1, n is definitely composite.
     * Do this by computing a^i (mod n) and looking for
     * nontrivial square roots of 1 along the way
     */
    private static long witness(long a, long i, long n)
    {
        if (i == 0)
            return 1;

        long x = witness(a, i / 2, n);
        if (x == 0)         // If n is recursively composite, stop
            return 0;

        // n is not prime if we find a nontrivial square root of 1
        long y = (x * x) % n;
        if (y == 1 && x != 1 && x != n - 1)
            return 0;

        if (i % 2 != 0)
            y = (a * y) % n;

        return y;
    }

    /**
     * The number of witnesses queried in randomized primality test.
     */
    public static final int TRIALS = 5;

    /**
     * Randomized primality test.
     * Adjust TRIALS to increase confidence level
     * @param n the number to test.
     * @return if false, n is definitely no prime.
     *      If true, n is probably prime.
     */
    public static boolean isPrime(long n)
    {
        Random r = new Random();

        for (int counter = 0; counter < TRIALS; counter++)
            if (witness(r.randomLong(2, n - 2), n - 1, n) != 1)
                return false;

        return true;
    }
}€

收费公路重建算法：驱动例程（伪代码）

    boolean turnpike(int[] x, DistSet d, int n)
    {
        x[1] = 0;
        x[n] = d.deleteMax();
        x[n - 1] = d.deleteMax();
        if (x[n] - x[n - 1] € d)
        {
            d.remove(x[n] - x[n - 1]);
            return place(x, d, n, 2, n - 2);
        }
        else
            return false;
    }

收费公路重建算法：回溯的步骤（伪代码）

    /**
     * Backtracking algorithm to place the points x[left] ... x[right].
     * x[1]...x[left - 1] and x[right + 1]...x[n] already tentatively placed.
     * If place returns true, then x[left]...x[right] will have values.
     */
    boolean place(int[] x, DistSet d, int n, int left, int right)
    {
        int dmax;
        boolean found = false;

        if (d.isEmpty())
            return true;

        dmax = d.findMax();

        // Check if setting x[right] = dmax is feasible
        if ( |x[j] - dmax| € d for all 1 <= j < left and right < j <= n )
        {
            x[right] = dmax;                // Try x[right] = dmax
            for (1 <= j < left, right < j <= n)
                d.remove( |x[j] - dmax| );
            found = place(x, d, n, left, right - 1);

            if (!found)         // Backtrack
                for (1 <= j < left, right < j <= n)     // Undo the deletion
                    d.insert(|x[j] - dmax|);
        }
            // If first attempt failed, try to see if setting
            // x[left] = x[n] - dmax is feasible
        if (!found && |x[n] - dmax - x[j]| € d for all 1 <= j < left and right < j <= n)
        {
            x[left] = x[n] - dmax;      // Same logic as before
            for (1 <= j < left, right < j <= n)
                d.remove(|x[n] - dmax - d[j]|);
            found = place(x, d, n, left + 1, right);

            if (!found)     // Backtrack
                for (1 <= j < left, right < j <= n)         // Undo the deletion
                    d.insert(|x[n] - dmax - x[j]|);
        }
        return found;
    }

极小极大三连游戏棋算法：计算机的选择，人的选择

public class MoveInfo
{
    public int move;
    public int value;

    public MoveInfo(int m, int v)
    { move = m; value = v;}

    /**
     * Recursive method to find best move for computer
     * MoveInfo.move returns a number from 1-9 indicating square.
     * Possible evaluations satisfy COMP_LOSS < DRAW < COMP_WIN.
     */
    public MoveInfo findCompMove()
    {
        int i, responseValue;
        int value, bestMove = 1;
        MoveInfo quickWinInfo;

        if (fullBoard())
            value = DRAW;
        else if ((quickWinInfo = immediateCompWin()) != null)
            return quickWinInfo;
        else
        {
            value = COMP_LOSS;
            for(i = 1; i <= 9; i++)     // Try each square
                if (isEmpty(i))
                {
                    place(i, COMP);
                    responseValue = findHumanMove().value;
                    unplace(i);     // Restore board

                    if (responseValue > value)
                    {
                            // Update best move
                        value = responseValue;
                        bestMove = i;
                    }
                }
        }
        return new MoveInfo(bestMove, value);
    }

    public MoveInfo finfHumanMove()
    {
        int i, responseValue;
        int value, bestMove = 1;
        MoveInfo quickWinInfo;

        if (fullBoard())
            value = DRAW;
        else if ((quickWinInfo = immediateHumanWin()) != null )
            return quickWinInfo;

        else
            {
                value = COMP_WIN;
                for (i = 1; i <= 9; i++)        // Try each square
                {
                    if (isEmpty(i))
                    {
                        place(i, HUMAN);
                        responseValue = findCompMove().value;
                        unplace(i);             // Restore board

                        if (responseValue < value)
                        {
                                // Update best move
                            value = responseValue;
                            bestMove = i;
                        }
                    }
                }
            }
            return new MoveInfo(bestMove, value);
    }
}

带有α-β裁减的极小极大三连游戏棋算法：计算机棋步的选择

    /**
     * Same as before, but perform alpha-beta pruning.
     * The main routine should make the call with
     * alpha = COMP_LOSS and beta = COMP_WIN.
     */
    public MoveInfo findCompMove(int alpha, int beta)
    {
        int i, responseValue;
        int value, bestMove = 1;
        MoveInfo quickWinInfo;
        
        if (fullBoard())
            value = DRAW;
        else if ((quickWinInfo = immediateCompWin()) != null)
            return quickWinInfo;
        else 
        {
            value = alpha;
            for (i = 1; i <= 9 && value < beta; i++)            // Try each square
            {
                if (isEmpty(i))
                {
                    place(i, COMP);
                    responseValue = findHumanMove(value, beta).value;
                    unplace(i);             // Restore board
                    
                    if (responseValue > value)
                    {
                            // Update best move
                        value = responseValue;
                        bestMove = i;
                    }
                }
            }
        }
        return new MoveInfo(bestMove, value);
    }