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);
}
}

算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-002如何改进算法的更多相关文章

  1. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-005计测试算法

    1. package algorithms.analysis14; import algorithms.util.StdOut; import algorithms.util.StdRandom; / ...

  2. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-007按位置,找出数组相关最大值

    Given an array a[] of N real numbers, design a linear-time algorithm to find the maximum value of a[ ...

  3. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-006BitonicMax

    package algorithms.analysis14; import algorithms.util.StdOut; import algorithms.util.StdRandom; /*** ...

  4. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-004计算内存

    1. 2. 3.字符串

  5. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-003定理

    1. 2. 3. 4. 5. 6.

  6. 算法Sedgewick第四版-第1章基础-1.4 Analysis of Algorithms-001分析步骤

    For many programs, developing a mathematical model of running timereduces to the following steps:■De ...

  7. 算法Sedgewick第四版-第1章基础-001递归

    一. 方法可以调用自己(如果你对递归概念感到奇怪,请完成练习 1.1.16 到练习 1.1.22).例如,下面给出了 BinarySearch 的 rank() 方法的另一种实现.我们会经常使用递归, ...

  8. 算法Sedgewick第四版-第1章基础-2.1Elementary Sortss-001选择排序法(Selection sort)

    一.介绍 1.算法的时间和空间间复杂度 2.特点 Running time is insensitive to input. The process of finding the smallest i ...

  9. 算法Sedgewick第四版-第1章基础-2.1Elementary Sortss-007归并排序(自下而上)

    一. 1. 2. 3. 二.代码 package algorithms.mergesort22; import algorithms.util.StdIn; import algorithms.uti ...

随机推荐

  1. 如何将Emmet安装到到 Sublime text 3?第二部分该插件还能让我们自定义快捷键呼出某个浏览器以预览页面

    看清楚哦~~这是Sublime text 3不是2的版本,两者的安装还是有区别的,下面的方法是我感觉比较简单的,其他的要命令什么的感觉太复杂了,经测试是OK的. 先关闭Sublime text 3: ...

  2. 手动安装mysql-5.0.45.tar.gz

    Linux下编译安装 安装环境:VMware9(桥接模式) + Linux bogon 2.6.32-642.3.1.el6.x86_64(查看linux版本信息:uname -a) 先给出MySQL ...

  3. 一文搞定 Git 相关概念和常用指令

    我几乎每天都使用 Git,但仍然无法记住很多命令. 通常,只需要记住下图中的 6 个命令就足以供日常使用.但是,为了确保使用地很顺滑,其实你应该记住 60 到 100 个命令. Git 相关术语 Gi ...

  4. [BZOJ1242]Fishing Net

    dbzoj vjudge1 vjudge2 sol 给一个无向图,求判定是不是弦图. sol 还是弦图那套理论. 复杂度是\(O(n^2)\)的,因为\(m\)本质上和\(n^2\)是同级的. cod ...

  5. shell while的用法

    1. #!/bin/shint=1while (( "$int < 10" ))doecho "$int"let "int++"don ...

  6. 使用.NET中的XML注释(二) -- 创建帮助文档入门篇

    一.摘要 在本系列的第一篇文章介绍了.NET中XML注释的用途, 本篇文章将讲解如何使用XML注释生成与MSDN一样的帮助文件.主要介绍NDoc的继承者:SandCastle. 二.背景 要生成帮助文 ...

  7. 系列文章----.Net程序员学用Oracle系列

    .Net程序员学用Oracle系列(18):PLSQL Developer 攻略 .Net程序员学用Oracle系列(17):数据库管理工具(SQL Plus) .Net程序员学用Oracle系列(1 ...

  8. 洛谷【P1616】疯狂的采药

    浅谈\(DP\):https://www.cnblogs.com/AKMer/p/10437525.html 题目传送门:https://www.luogu.org/problemnew/show/P ...

  9. RCE、exp、Exploit、Exploit Pack、exp-gui、Payload、MetaSploit都是啥

    对于走在安全路上的小菜来说,这几个exp.Exploit.Exploit Pack.exp-gui.Payload.MetaSploit名词着实把人转的不轻,下面给大家解释下: RCE,remote ...

  10. Caused by: java.lang.IncompatibleClassChangeError: Implementing class

    Caused by: java.lang.IncompatibleClassChangeError: Implementing class 可能是导入的jar包重复. 尤其在Maven引用中,请查看是 ...