算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-002如何改进算法

1.

 package algorithms.analysis14;

 import algorithms.util.In;
 import algorithms.util.StdOut;

 /******************************************************************************
  *  Compilation:  javac TwoSum.java
  *  Execution:    java TwoSum input.txt
  *  Dependencies: StdOut.java In.java Stopwatch.java
  *  Data files:   http://algs4.cs.princeton.edu/14analysis/1Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/2Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/4Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/8Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/16Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/32Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/1Mints.txt
  *
  *  A program with N^2 running time. Read in N integers
  *  and counts the number of pairs that sum to exactly 0.
  *
  *
  *  Limitations
  *  -----------
  *     - we ignore integer overflow
  *
  *
  *  % java TwoSum 2Kints.txt
  *  2
  *
  *  % java TwoSum 1Kints.txt
  *  1
  *
  *  % java TwoSum 2Kints.txt
  *  2
  *
  *  % java TwoSum 4Kints.txt
  *  3
  *
  *  % java TwoSum 8Kints.txt
  *  19
  *
  *  % java TwoSum 16Kints.txt
  *  66
  *
  *  % java TwoSum 32Kints.txt
  *  273
  *
  ******************************************************************************/

 public class TwoSum {

     // print distinct pairs (i, j) such that a[i] + a[j]  = 0
     public static void printAll(int[] a) {
         int N = a.length;
         for (int i = 0; i < N; i++) {
             for (int j = i+1; j < N; j++) {
                 if (a[i] + a[j] == 0) {
                     StdOut.println(a[i] + " " + a[j]);
                 }
             }
         }
     } 

     // return number of distinct triples (i, j) such that a[i] + a[j] = 0
     public static int count(int[] a) {
         int N = a.length;
         int cnt = 0;
         for (int i = 0; i < N; i++) {
             for (int j = i+1; j < N; j++) {
                 if (a[i] + a[j] == 0) {
                     cnt++;
                 }
             }
         }
         return cnt;
     } 

     public static void main(String[] args)  {
         In in = new In(args[0]);
         int[] a = in.readAllInts();
         Stopwatch timer = new Stopwatch();
         int cnt = count(a);
         StdOut.println("elapsed time = " + timer.elapsedTime());
         StdOut.println(cnt);
     }
 } 

The answer to this question is that we have discussed and used two classic algorithms,
mergesort and binary search, have introduced the facts that the mergesort is linearith-
mic and binary search is logarithmic.

2.

 package algorithms.analysis14;

 /******************************************************************************
  *  Compilation:  javac TwoSumFast.java
  *  Execution:    java TwoSumFast input.txt
  *  Dependencies: In.java Stopwatch.java
  *  Data files:   http://algs4.cs.princeton.edu/14analysis/1Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/2Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/4Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/8Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/16Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/32Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/1Mints.txt
  *
  *  A program with N log N running time. Read in N integers
  *  and counts the number of pairs that sum to exactly 0.
  *
  *  Limitations
  *  -----------
  *     - we ignore integer overflow
  *
  *
  *  % java TwoSumFast 2Kints.txt
  *  2
  *
  *  % java TwoSumFast 1Kints.txt
  *  1
  *
  *  % java TwoSumFast 2Kints.txt
  *  2
  *
  *  % java TwoSumFast 4Kints.txt
  *  3
  *
  *  % java TwoSumFast 8Kints.txt
  *  19
  *
  *  % java TwoSumFast 16Kints.txt
  *  66
  *
  *  % java TwoSumFast 32Kints.txt
  *  273
  *
  ******************************************************************************/

 import java.util.Arrays;

 import algorithms.util.In;
 import algorithms.util.StdOut;

 public class TwoSumFast {

     // print distinct pairs (i, j) such that a[i] + a[j] = 0
     public static void printAll(int[] a) {
         int N = a.length;
         Arrays.sort(a);
         for (int i = 0; i < N; i++) {
             int j = Arrays.binarySearch(a, -a[i]);
             if (j > i) StdOut.println(a[i] + " " + a[j]);
         }
     } 

     // return number of distinct pairs (i, j) such that a[i] + a[j] = 0
     public static int count(int[] a) {
         int N = a.length;
         Arrays.sort(a);
         int cnt = 0;
         for (int i = 0; i < N; i++) {
             int j = Arrays.binarySearch(a, -a[i]);
             if (j > i) cnt++;
         }
         return cnt;
     } 

     public static void main(String[] args)  {
         In in = new In(args[0]);
         int[] a = in.readAllInts();
         int cnt = count(a);
         StdOut.println(cnt);
     }
 } 

　　

3.

 package algorithms.analysis14;

 import algorithms.util.In;
 import algorithms.util.StdOut;

 /******************************************************************************
  *  Compilation:  javac ThreeSum.java
  *  Execution:    java ThreeSum input.txt
  *  Dependencies: In.java StdOut.java Stopwatch.java
  *  Data files:   http://algs4.cs.princeton.edu/14analysis/1Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/2Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/4Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/8Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/16Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/32Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/1Mints.txt
  *
  *  A program with cubic running time. Read in N integers
  *  and counts the number of triples that sum to exactly 0
  *  (ignoring integer overflow).
  *
  *  % java ThreeSum 1Kints.txt
  *  70
  *
  *  % java ThreeSum 2Kints.txt
  *  528
  *
  *  % java ThreeSum 4Kints.txt
  *  4039
  *
  ******************************************************************************/

 /**
  *  The <tt>ThreeSum</tt> class provides static methods for counting
  *  and printing the number of triples in an array of integers that sum to 0
  *  (ignoring integer overflow).
  *  <p>
  *  This implementation uses a triply nested loop and takes proportional to N^3,
  *  where N is the number of integers.
  *  <p>
  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/14analysis">Section 1.4</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  */
 public class ThreeSum {

     // Do not instantiate.
     private ThreeSum() { }

     /**
      * Prints to standard output the (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0.
      * @param a the array of integers
      */
     public static void printAll(int[] a) {
         int N = a.length;
         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) {
                         StdOut.println(a[i] + " " + a[j] + " " + a[k]);
                     }
                 }
             }
         }
     } 

     /**
      * Returns the number of triples (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0.
      * @param a the array of integers
      * @return the number of triples (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0
      */
     public static int count(int[] a) {
         int N = a.length;
         int cnt = 0;
         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;
     } 

     /**
      * Reads in a sequence of integers from a file, specified as a command-line argument;
      * counts the number of triples sum to exactly zero; prints out the time to perform
      * the computation.
      */
     public static void main(String[] args)  {
         In in = new In(args[0]);
         int[] a = in.readAllInts();

         Stopwatch timer = new Stopwatch();
         int cnt = count(a);
         StdOut.println("elapsed time = " + timer.elapsedTime());
         StdOut.println(cnt);
     }
 } 

4.

 package algorithms.analysis14;

 /******************************************************************************
  *  Compilation:  javac ThreeSumFast.java
  *  Execution:    java ThreeSumFast input.txt
  *  Dependencies: StdOut.java In.java Stopwatch.java
  *  Data files:   http://algs4.cs.princeton.edu/14analysis/1Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/2Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/4Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/8Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/16Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/32Kints.txt
  *                http://algs4.cs.princeton.edu/14analysis/1Mints.txt
  *
  *  A program with N^2 log N running time. Read in N integers
  *  and counts the number of triples that sum to exactly 0.
  *
  *  Limitations
  *  -----------
  *     - we ignore integer overflow
  *     - doesn't handle case when input has duplicates
  *
  *
  *  % java ThreeSumFast 1Kints.txt
  *  70
  *
  *  % java ThreeSumFast 2Kints.txt
  *  528
  *
  *  % java ThreeSumFast 4Kints.txt
  *  4039
  *
  *  % java ThreeSumFast 8Kints.txt
  *  32074
  *
  *  % java ThreeSumFast 16Kints.txt
  *  255181
  *
  *  % java ThreeSumFast 32Kints.txt
  *  2052358
  *
  ******************************************************************************/

 import java.util.Arrays;

 import algorithms.util.In;
 import algorithms.util.StdOut;

 /**
  *  The <tt>ThreeSumFast</tt> class provides static methods for counting
  *  and printing the number of triples in an array of distinct integers that
  *  sum to 0 (ignoring integer overflow).
  *  <p>
  *  This implementation uses sorting and binary search and takes time
  *  proportional to N^2 log N, where N is the number of integers.
  *  <p>
  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/14analysis">Section 1.4</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  */
 public class ThreeSumFast {

     // Do not instantiate.
     private ThreeSumFast() { }

     // returns true if the sorted array a[] contains any duplicated integers
     private static boolean containsDuplicates(int[] a) {
         for (int i = 1; i < a.length; i++)
             if (a[i] == a[i-1]) return true;
         return false;
     }

     /**
      * Prints to standard output the (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0.
      * @param a the array of integers
      * @throws IllegalArgumentException if the array contains duplicate integers
      */
     public static void printAll(int[] a) {
         int N = a.length;
         Arrays.sort(a);
         if (containsDuplicates(a)) throw new IllegalArgumentException("array contains duplicate integers");
         for (int i = 0; i < N; i++) {
             for (int j = i+1; j < N; j++) {
                 int k = Arrays.binarySearch(a, -(a[i] + a[j]));
                 if (k > j) StdOut.println(a[i] + " " + a[j] + " " + a[k]);
             }
         }
     } 

     /**
      * Returns the number of triples (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0.
      * @param a the array of integers
      * @return the number of triples (i, j, k) with i < j < k such that a[i] + a[j] + a[k] == 0
      */
     public static int count(int[] a) {
         int N = a.length;
         Arrays.sort(a);
         if (containsDuplicates(a)) throw new IllegalArgumentException("array contains duplicate integers");
         int cnt = 0;
         for (int i = 0; i < N; i++) {
             for (int j = i+1; j < N; j++) {
                 int k = Arrays.binarySearch(a, -(a[i] + a[j]));
                 if (k > j) cnt++;
             }
         }
         return cnt;
     } 

     /**
      * Reads in a sequence of distinct integers from a file, specified as a command-line argument;
      * counts the number of triples sum to exactly zero; prints out the time to perform
      * the computation.
      */
     public static void main(String[] args)  {
         In in = new In(args[0]);
         int[] a = in.readAllInts();
         int cnt = count(a);
         StdOut.println(cnt);
     }
 }