普林斯顿大学算法Week3:CollinearPoints共线模式识别(99分)--总结及代码

最新推荐文章于 2022-02-18 20:46:55 发布
原创 最新推荐文章于 2022-02-18 20:46:55 发布 · 1.7k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

总结

(代码有详细注释)
  1. 本课讲了归并排序,作业应用是排序进行共线的模式识别,java1.8中的排序用的是tim排序,结合了归并排序与插入排序,属于稳定排序:排序之后相同元素的相对位置会不会改变
  2. Point.java中有个非常重要的方法,compareTo(),它定义:纵坐标越小则点越小,如果纵坐标相同,那么横坐标越小则点越小.(如果作业中要求横坐标也是按顺序排列,那么排序后的点集映射到二维坐标系中是非递减的折线, 这样找共线只用一层循环即可,可惜作业没加上对x的限制)
  3. 比较大小,一开始我用的是points[i-1] == point[i],尽管坐标相同但是points[i-1]不等于points[i]
    因为points[i-1]和points[i]表示引用,在堆中指向两个不同的地址,比较大小得用points[i-1].compareTo(points[i])
  4. 在FastCollinearPoints.java中,一定要注意什么时候对共线点数变量count进行判断,有两种情况,一个是,相邻元素与参考点的斜率不同;另一个是循环到最后一个元素.这两种情况在代码注释中有解释
  5. 唯一一处FAILED,扣了1分,没系统学过java,先跳过了
Test 7: check for dependence on either compareTo() or compare()
        returning { -1, +1, 0 } instead of { negative integer,
        positive integer, zero }
  * filename = equidistant.txt
    - number of entries in student   solution: 0
    - number of entries in reference solution: 4
    - 4 missing entries in student solution, including: '(30000, 0) -> (20000, 10000) -> (10000, 20000) -> (0, 30000)'
==> FAILED
  1. week3课件中,递归调用的图示:
    这是包含两个递归调用的递归 (图示只画了一半)
    Merge.jpg

代码

(如需提交,请删除中文注释)

一:Point.java

import java.util.Comparator;
import edu.princeton.cs.algs4.StdDraw;
public class Point implements Comparable<Point> {
    // x-coordinate of this point
    private final int x;
    // y-coordinate of this point
    private final int y;
    // constructs the point (x, y)
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    } 
    // draws this point
    public   void draw() {
        StdDraw.point(x,y);
    }
    // draws the line segment from this point to that point
    public   void drawTo(Point that) {
        StdDraw.line(this.x, this.y, that.x, that.y);
    }
    // string representation
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
    // compare two points by y-coordinates, breaking ties by x-coordinates  
    public  int compareTo(Point that) {
        if(y<that.y || (y==that.y && x<that.x)) return -1;
        else if(y==that.y && x==that.x) return 0;
        else return +1;
    }   
    // the slope between this point and that point
    public  double slopeTo(Point that) {
        if(x==that.x && y==that.y) return Double.NEGATIVE_INFINITY;
        if(x==that.x && y!=that.y) return Double.POSITIVE_INFINITY;     
        if(y==that.y) return +0.0;
        return (double)(y-that.y)/(x-that.x);
    }
    // compare two points by slopes they make with this point
    public Comparator<Point> slopeOrder(){
        return new SlopeOrder();
    }
    //nested class
    //sort rule
    private class SlopeOrder implements Comparator<Point>{
        public int compare(Point p,Point q) {
            //p点斜率大
            if(slopeTo(p)<slopeTo(q)) return -1;
            //p点斜率小
            else if(slopeTo(p)>slopeTo(q)) return 1;
            //p,q斜率相等
            else return 0;
        }
    }

    public static void main(String[] args) {
        Point p1 = new Point(0,0);
        Point p2 = new Point(1,1);
        Point p3 = new Point(2,2);
        Point p4 = new Point(2,1);
        Point p5 = new Point(4,1);
        System.out.println("p1.compareTo(p1) is "+p1.compareTo(p2));
        System.out.println("p2.compareTo(p1) is "+p2.compareTo(p1));
        System.out.println("p1.compareTo(p1) is "+p1.compareTo(p1)+"\n");

        System.out.println("p1.slopeTo(p2) is " +p1.slopeTo(p2));
        System.out.println("p1.slopeTo(p4) is "+p1.slopeTo(p4));
        System.out.println("p1.slopeTo(p1) is "+p1.slopeTo(p1));
        System.out.println("p3.slopeTo(p4) is "+p3.slopeTo(p4));
        System.out.println("p2.slopeTo(p5) is "+p2.slopeTo(p5));
    }
}

二:BruteCollinearPoints.java

import java.util.ArrayList;
import java.util.Arrays;
import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.Insertion;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdDraw;

public class BruteCollinearPoints {
     //to store line segments
     private ArrayList<LineSegment> LineSegmentList;
     //to store the given points
     private Point[] points;

     //在构造函数中找出由4点构成的线段(作业说了:没有5点及更多点共线的情况)
     // finds all line segments containing 4 point
     public BruteCollinearPoints(Point[] pointsIn) { 
         //三种异常
         //一:if the argument to the constructor is null
         System.out.println(" a ");
         if(pointsIn == null) throw new IllegalArgumentException("there is no point");
         //二:if any point in the array is null
         int N = pointsIn.length;
         for(int i=0;i<N;i++) if(pointsIn[i]==null) throw new IllegalArgumentException("exist null point");
         //三:if the argument to the constructor contains a repeated point
         //检查是否有重复的点,先排序,再查重会方便,作业允许这样: For example, you may use Arrays.sort()
         points = new Point[N];
         for(int i=0;i<N;i++) points[i] = pointsIn[i];
         Arrays.sort(points);
         for(int i=1;i<N;i++) if(points[i-1].compareTo(points[i])==0) throw new IllegalArgumentException("exist repeated point"); 

         //to save every required line segment
         LineSegmentList = new ArrayList<LineSegment>();

         //find line segment
         for(int dot1=0;dot1<=N-4;dot1++) {
             for(int dot2=dot1+1;dot2<=N-3;dot2++) {
                 //k12:the slope between point[dot2] and point[dot1]
                 double k12 = points[dot2].slopeTo(points[dot1]);
                 for(int dot3=dot2+1;dot3<=N-2;dot3++) {
                     //k13:the slope between point[dot3] and point[dot1]
                     double k13 = points[dot3].slopeTo(points[dot1]);
                     if(k13 != k12) continue;
                     for(int dot4=dot3+1;dot4<=N-1;dot4++) {
                        //k14:the slope between point[dot4] and point[dot1]
                         double k14 = points[dot4].slopeTo(points[dot1]);
                         if(k14 != k12) continue;
                         //find a line segment
                         LineSegment linesegment = new LineSegment(points[dot1],points[dot4]);
                         LineSegmentList.add(linesegment);
                     }
                 }
             }
         }
     }
     // the number of line segments
     public int numberOfSegments() {
         return LineSegmentList.size();
     }
     // the line segments
     public LineSegment[] segments() {
         LineSegment[] segments = new LineSegment[LineSegmentList.size()];
         int index=0;
         for(LineSegment Line : LineSegmentList) {
             segments[index++] = Line;
         }
         return segments;
     }    
     //main
     public static void main(String[] args) {
            In in = new In("src/week3/input8.txt"); 
            int n = in.readInt();
            StdOut.println("total "+n+" points");
            Point[] points = new Point[n];
            for (int i = 0; i < n; i++) {
                int x = in.readInt();
                int y = in.readInt();
                StdOut.println("("+x+","+y+")"); 
                points[i] = new Point(x,y);
            }       
            //draw the points
            StdDraw.enableDoubleBuffering();
            StdDraw.setXscale(0, 32768);
            StdDraw.setYscale(0, 32768);
            StdDraw.setPenColor(StdDraw.RED);
            StdDraw.setPenRadius(0.01);
            for (Point p : points) {
                p.draw();
            }
            StdDraw.show();              
            // print and draw the line segments
            BruteCollinearPoints collinear = new BruteCollinearPoints(points);
            StdOut.println(collinear.numberOfSegments());
            for (LineSegment segment : collinear.segments()) {
                StdOut.println(segment);
                segment.draw();
            }
            StdDraw.show();          
     }
}

三:FastCollinearPoints.java

import java.util.ArrayList;
import java.util.Arrays;
import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdOut;

//much faster than the brute-force solution
public class FastCollinearPoints {
    //to store line segments
    private ArrayList<LineSegment> LineSegmentList;
    //to store the given points
    private Point[] points;

    // finds all line segments containing 4 or more points
    public FastCollinearPoints(Point[] pointsIn) {
         //三种异常
         //一:if the argument to the constructor is null
         if(pointsIn == null) throw new IllegalArgumentException("there is no point");
        //number of points
         int N=pointsIn.length;
         //二:if any point in the array is null
         for(int i=0;i<N;i++) if(pointsIn[i]==null) throw new IllegalArgumentException("exist null point");
         //三:if the argument to the constructor contains a repeated point
         //检查是否有重复的点,先排序,再查重会方便,作业允许这样: For example, you may use        Arrays.sort()
         //同时有利于后面排除重复线段
         points = new Point[N];
         for(int i=0;i<N;i++) points[i] = pointsIn[i];
         //用的是结合了归并和插入的tim排序,稳定排序
         Arrays.sort(points);
         for(int i=1;i<N;i++) if(points[i-1].compareTo(points[i])==0) throw new IllegalArgumentException("exist repeated point");

         //to save every required line segment
         LineSegmentList = new ArrayList<LineSegment>();


         //当前的参考点
         Point currentCheck;
         //对照点重新存储,不包括参考点,共N-1个
         Point[] otherPoints = new Point[N-1];
         //开始比较斜率,一个一个来
         for (int i=0;i<N;i++) {
             currentCheck = points[i];
             // copy points without Point currentCheck to otherPoints
             for(int j=0;j<N;j++) {
                 if(j<i) otherPoints[j] = points[j];
                 if(j>i) otherPoints[j-1] = points[j];
             }

             //根据斜率对点排序
             //用的是结合了归并和插入的tim排序,稳定排序
             Arrays.sort(otherPoints,currentCheck.slopeOrder());
             //遍历已经排序的otherPoints找线段
             //注意,归并和插入排序都是稳定的,所以tim排序是稳定的,这非常重要
             //配合Point的compareTo方法,可以直接过滤掉重复线段
             //一开始没太注意compareTo方法,后来发现这个方法能固定住点之间的相对位置,所以可以过滤重复线段
             //两点共线
             int count=2;
             for(int k=1;k<N-1;k++) {
                 double k1 = otherPoints[k-1].slopeTo(currentCheck);
                 double k2 = otherPoints[k].slopeTo(currentCheck);
                 if(k1==k2) {
                     count++;
                     //当循环到最后一个点,同时这个点和前面的点共线
                     if(k==N-2) {
                         //如果4点及以上共线,并且otherPoints中与参考点共线且排在最左边的点比参考点大的话,注意此处是遍历到头,所以索引是k-count+2
                         if(count>=4 && currentCheck.compareTo(otherPoints[k-count+2])==-1) { 
                             //线段起点
                             Point start = currentCheck;
                             //线段终点
                             Point end = otherPoints[k];
                             LineSegment linesegment = new LineSegment(start,end);
                             LineSegmentList.add(linesegment);
                         }
                     }
                 }
                 else{
                    //如果4点及以上共线,并且otherPoints中与参考点共线且排在最左边的点比参考点大的话,索引是k-count+1
                     if(count>=4 && currentCheck.compareTo(otherPoints[k-count+1])==-1) {
                             Point start = currentCheck;
                             Point end = otherPoints[k-1];
                             LineSegment linesegment = new LineSegment(start,end);
                             LineSegmentList.add(linesegment);
                     }
                     count=2;
                 }
             }
         }
    }

    // the number of line segments
    public  int numberOfSegments() {
        return LineSegmentList.size();
    }
    // the line segments
    public LineSegment[] segments() {
        LineSegment[] segments = new LineSegment[LineSegmentList.size()];
         int index=0;
         for(LineSegment Line : LineSegmentList) {
             segments[index++] = Line;
         }
         return segments;
    }

    //main
         public static void main(String[] args) {
                In in = new In("src/week3/input9.txt"); 
                int n = in.readInt();
                StdOut.println("total "+n+" points");
                Point[] points = new Point[n];
                for (int i = 0; i < n; i++) {
                    int x = in.readInt();
                    int y = in.readInt();
                    StdOut.println("("+x+","+y+")"); 
                    points[i] = new Point(x,y);
                }

                //draw the points
                StdDraw.enableDoubleBuffering();
                StdDraw.setXscale(0, 32768);
                StdDraw.setYscale(0, 32768);
                StdDraw.setPenColor(StdDraw.RED);
                StdDraw.setPenRadius(0.01);
                for (Point p : points) {
                    p.draw();
                }
                StdDraw.show();

                //print and draw the line segments
                FastCollinearPoints collinear = new FastCollinearPoints(points);
                StdOut.println(collinear.numberOfSegments());
                for (LineSegment segment : collinear.segments()) {
                    StdOut.println(segment);
                    segment.draw();
                }
                StdDraw.show();          
         }
}

WelcomeToMyBlog

Coursera Algorithm Ⅰ week3 编程作业 Collinear Points
RedemptionC的博客
09-12 501
代码：https://github.com/RedemptionC/CourseraAlgorithms/tree/master/collinear 这是学完归并排序和快速排序之后的编程作业，需要提交3个类：BruteCollinearPoints.java，FastCollinearPoints.java和Point.java 在本文最后，会附上对课堂上教过的排序算法的总结 问题描述很简单：给出一系列的点，将其中包含四个点以上的最大线段找出来 这里的最大是指，如果一条线段包含五个点，那么就不要.
普林斯顿算法课作业的python实现（三）Collinear Points
weixin_43084570的博客
12-07 790
Collinear Points问题思路代码结果 问题 这一次的编程作业是判断共线点。 问题大致描述如下： 给定平面上一些点，判断其中是否有四个及以上的点共线，把所有这些点找出来并连线。原题链接 思路 一种做法是暴力求解，遍历所有四个点，判断其是否共线。这种做法简单粗暴，但是时间复杂度在 O(N4)O(N^4)O(N4)。 另一种做法是以其中一个点为坐标原点，计算其他点到该点的倾角，按倾角的大小对其他点排序，找出三个以上连续相同的点，与该点本身，构成共线。遍历所有的点，重复上述操作，可得到所有共线组。 这
Collinear Points
sutungpo的博客
02-18 203
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录assignment specificationclass Pointclass BruteCollinearPointsclass FastCollinearPoints总结 assignment specification find link here specification class Point import edu.princeton.cs.algs4.StdDraw; import java.util.Com
【Coursera】编程题 Collinear Points - Algorithms Part1, Week3
OldDreamHYN的博客
03-13 1690
题目概述：http://coursera.cs.princeton.edu/algs4/assignments/collinear.html Point类和暴力算法（O(n^4)）都很简单，就不写了。 写一个把复杂度降到n^2lg(n)的算法。 感觉写出来的东西很混乱。。 import java.util.ArrayList; import java.util.Arrays; i
普林斯顿大学算法 Week3:CollinearPoints 共线模式识别(95分)
ichigoooo_wu的博客
04-25 706
FastCollinearPoints的实现中，个人认为最关键的一步是使用Merge Sort对以每个点为出发点的线段进行排序而不能用QuickSort，其原因在与排序的Stability稳定性。MergeSort不会打乱之前因为对Points排序后形成的有序线段组，才能保证后面循环检查线段斜率操作的有效性。 关于排序算法Stability的说明，见《算法（第四版）》第217页的2.5.1.8稳...
【算法 队列】BruteCollinearPoints && FastCollinearPoints 实现
在微风中飘落的博客
01-28 883
FastCollinearPoints 快速四点共线判断FastCollinearPoints.javaPoint.javaBruteCollinearPoints.java评分 FastCollinearPoints.java 快速判断 四点共线模式 核心思想：利用 归并排序+插入排序的 Stable 特性 => SQL 的 字母排序分组group by+order by
Week3 Assignment - Princeton-Algorithms-PartI
Weiran Liu的渣技术小专栏
02-16 1万+
题注 Princeton Algorithm Part I中Week 3的Assignment实际上也是很早前就做完了，不过因为懒，一直没放到网上来… 正好新周期的Algorithm课也督促我复习一遍算法知识，另一方面也有机会把所有的Assignment做完吧。上个周期中，Week 4的Assignment没有拿到满分，就萌生退意了。这回卷土重来，希望能拿到一个Perfect的结果（当然了，Pr
Programming Assignment: Collinear Points
仍歌杨柳春风
05-08 1600
Programming Assignment: Collinear Points
Programming Assignment 3: Pattern Recognition
5262yz的博客
03-20 2304
Pattern Recognition 给定点的集合，实现对于线段的识别。 Point.java Point类中主要实现了关于点和斜率的比较方法 import java.util.Arrays; import java.util.Comparator; import edu.princeton.cs.algs4.StdDraw; import edu.princeton.cs.al...
algorithm第三周作业 Collinear Points
wuqindeyunque的博客
02-12 1095
cousera 上algorithm part I第三周课程讲述的是排序，包括插入排序、选择排序、希尔排序、归并排序和快速排序。其配套作业为Collinear Points,题目大意为给定若干点，求出其中的有四个及以上点共线的线段。 要求提交三个文件，Point.java，BruteCollinearPoints.java,FastCollinearPoints.java。 Point类 给定的的...
机器学习小窍门：Python 帮你进行特征选择
热门推荐
xiangz_csdn的博客
09-19 1万+
[转] https://www.leiphone.com/news/201807/3gGDmue2OXYZE0vQ.html   特征选择，也就是从数据集中找出并选择最有用特征的过程，是机器学习工作流中一个非常重要的步骤。不必要的特征降低了训练速度，降低了模型的可解释性，最重要的是降低了测试数据集的泛化能力。 在做机器学习问题的过程中，我们总是在重复应用一些特征选择方法，这很令人沮丧。因此我...
机器学习 特征工程-特征选择
Galbraith_的博客
12-30 1100
特征选择(FeatureSelection)\color{DodgerBlue}{特征选择(Feature Selection)}特征选择(FeatureSelection)  在机器学习流程中，前期获取“足量”的训练数据是至关重要的一个步骤。“足量”包括两个方面：一个是特征层面，另一个是训练数据量。但是并不是所有的特征都会用于模型训练，主要是因为不必要的特征不仅会降低训练速度、降低模型的可解释性...
算法导论第四版学习——习题三Collinear Points
dianrangzhuo4225的博客
09-25 440
题目正文： http://coursera.cs.princeton.edu/algs4/assignments/collinear.html 作业难点： 1、仔细思考会感觉有很多实现方法，但是如果没有适当使用排序，算法时间复杂度就会轻易超过要求。（包括暴力算法） 2、隐含需要实现自己的数据结构用来组织“线”的集合，当然也可以用Stack或者Queue或者LinkedList，但...
Coursera普林斯顿大学算法Week3: Pattern Recognition 模式识别
静远小和尚的博客
07-22 892
任务链接:http://coursera.cs.princeton.edu/algs4/assignments/collinear.html 本次任务主要是比较器Comparator的使用。 在暴力求解时，可以不必在最后再对三个斜率进行比较，先比较两个可以有效减少算法时间。 在快速求解时，借助了一个内部类构成的数组存储点和斜率，并将这个数组按斜率进行排序，相同斜率的即为同一直线。 在暴力和...
图像纠偏的算法总结
机器视觉之家
04-19 7657
1）对于有表格（虚线或者实线）内容的图像，如票据，可以参考文章：基于方向投影的票据图像倾斜检测方法。                        摘 　要:针对含有表格线的票据图像,提出一种基于整数Bresenham算法求方向投影的倾斜检测方法,并与Hough变换方法进行了比较。实验结果表明,该算法能快速准确地测量出票据图像的倾斜角度,并具有很强的抗干扰性和应用适应性。
Matlab交互式生成特定曲线
DC的陋室
08-28 4638
工程中，经常要产生测试数据，比如特定包含噪声的曲线。以下是Matlab实现的通过鼠标拾取坐标点，然后生成包含直线和圆弧的x,y坐标的代码。 操作方式：鼠标拾取一个起点，弹出选择菜单，选择直线或者圆弧，选择直线后，鼠标拾取第二个点；选择圆弧之后，鼠标拾取另外两个点，通过三个点拟合圆弧并生成圆弧数据。 主文件： clc,clear,close all% figure axis([0
Princeton Algorithms: Part 1 [week 3:Mergesort]
无知的我
07-03 1541
Exercises
Algorithm I assignment Collinear
weixin_30312659的博客
10-05 177
这本来应该是第三周的作业，但是由于其他作业逼近deadline，暂时推后了一周完成。 这周的assignment大大提高了我对这门课的看法，不得不说，Algorithms这门课的assignment部分设计得很好。为什么好？个人认为有以下几点： 程序要求解耦 循序渐进，这周的作业不允许使用hashcode() 输入变量不允许被程序改变 能做到1、3两点，在工程中也是高质量代码的体...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值