Introduction to Divide-and-Conquer

1. Recursion

　　According to wikipedia,  Recursion is the process of repeating itself in a self-similar way. A good case in point is the procedure of Euclidean Algorithm:

    public static int gcd(int m,int n,int[] ref) {
        // Calculate the greatest common divisor of m and n
        // Precondition: n>=0 && m>0 && ref.length>=2
        // Postcondition: the gcd of m and n is returned
        //        and gcd(m,n) = m*ref[0]+n*ref[1]
        if (n==0) {
            ref[0] = 1;
            ref[1] = 0;
            return m;
        } else {
            int val = gcd(n,m%n,ref);
            int y = ref[1];
            ref[1] = ref[0]-m/n*y;
            ref[0] = y;
            return val;
        }
    }

2. Divide-and-Conquer Algorithms

　　Sometimes it is entirely possible for us to gain a better time performance if we divide the problem into several sub-problems and solve them recursively before finally accomplishing the total task. This is what we call the family of Divide-and-Conquer Algorithms, and I shall give you some examples:

　　(1)  To calculate the nth power of a natural number x, instead of multiplying x to the temporary result repeatedly, we'd better use the following method:

    public static long pow(int x,int n) {
        // Return the nth power of a natural number x
        if (n==0) {
            return 1;
        } else {
            long tmp = pow(x,n>>1);
            if ((n&1)!=0) {
                return tmp*tmp*x;
            } else {
                return tmp*tmp;
            }
        }
    }

　　(2)  Some sorting algorithms, such as Quick Sort, Merge Sort and so forth.

　　(3)  Multiplication of two big integers, a trick invented by Gauss.

　　(4)  Multiplication of two big matrices, what is called Strassen Algorithm.

　　(5)  Multiplication of two polynomials, the well-known Fast Fourier Transform.

　　(6)  Determining the nearest point pair among all the given points in a plane.

3. Master Theorem

　　To determine the time complexity of a divide-and-conquer algorithm remains to be a tricky work since some recursions are strikingly intractable. Whereas there is a theorem that can assist us a lot in most cases. The following figure is by courtesy of the renowned algorithm cookbook CLRS:

                                                         

4. My Solution to USACO Problem "rect1"

　　Here I wish to show you an example that I used a divide-and-conquer method to solve a USACO training problem called Shaping Regions:

import java.io.*;
import java.util.*;

public class rect1 {
    public static Scanner input;
    public static PrintWriter output;
    public static int num;        // number of rectangles
    public static int [] color;        //  areas of different colors
    public static int [][] rect;        // rectangle information
    
    public static int cover(int i,int x1,int y1,int x2,int y2) {
        // The area of Rect(x1,y1,x2,y2) that is not covered
        //        by any one from Rect[i] to Rect[num]
        if (x1>=x2||y1>=y2) {
            return 0;
        } else if (i>num) {
            return (x2-x1)*(y2-y1);
        }
        // calculate the overlapping part Rect(a,b,c,d)
        int a = (rect[i][0]>x1)? rect[i][0]:x1;
        int b = (rect[i][1]>y1)? rect[i][1]:y1;
        int c = (rect[i][2]<x2)? rect[i][2]:x2;
        int d = (rect[i][3]<y2)? rect[i][3]:y2;
        if (a>=c || b>=d)  {
            // no overlapping area
            return cover(i+1,x1,y1,x2,y2);
        } else {
            // divide the remaining part into 8 parts
            int val = 0;
            val += cover(i+1,x1,y1,a,b);
            val += cover(i+1,a,y1,c,b);
            val += cover(i+1,c,y1,x2,b);
            val += cover(i+1,c,b,x2,d);
            val += cover(i+1,c,d,x2,y2);
            val += cover(i+1,a,d,c,y2);
            val += cover(i+1,x1,d,a,y2);
            val += cover(i+1,x1,b,a,d);
            return val;
        }
    }
    public static void getInput() throws IOException {
        // Get the input data:
        input = new Scanner(new FileReader("rect1.in"));
        color = new int [2500];
        int wid = input.nextInt();
        int len = input.nextInt();
        num = input.nextInt();
        rect = new int [num+1][5];
        //    consider background as Rect[0]
        rect[0][2] = wid;
        rect[0][3] = len;
        for (int i=1;i<=num;i++) {
            // following info of  rectangles
            rect[i][0] = input.nextInt();
            rect[i][1] = input.nextInt();
            rect[i][2] = input.nextInt();
            rect[i][3] = input.nextInt();
            rect[i][4] = input.nextInt()-1;    // color
        }
        input.close();
    }
    public static void printAns() throws IOException {
        // Print the final answer:
        output = new PrintWriter(new FileWriter("rect1.out"));
        for (int i=0;i<2500;i++) {
            if (color[i]>0) {
                output.println(i+1+" "+color[i]);
            }
        }
        output.close();
    }
    public static void main(String[] args) throws IOException {
        getInput();
        for (int i=0;i<num;i++) {
            // the area of Rect[i] that can be shown ultimately
            color[rect[i][4]] += 
                    cover(i+1,rect[i][0],rect[i][1],rect[i][2],rect[i][3]);
        }
        // the top rectangle is covered by none
        color[rect[num][4]] += 
                (rect[num][2]-rect[num][0])*(rect[num][3]-rect[num][1]);
        printAns();
    }
} 

References:

　　1. Cormen, T. H. et al. Introduction to Algorithms[M]. 北京：机械工业出版社，2006-09

　　2. Dasgupta, Sanjoy, Christos Papadimitriou, and Umesh Vazirani. Algorithms[M].北京：机械工业出版社，2009-01-01