2018年3月23日牛客網舉行了騰訊實習線上模擬筆試

先看題目：正方形判斷

• 思路1:
  用4個點,任意三點組成一個等邊直角三角形,並且斜邊是直角邊的根號2倍(設斜邊為y,那麼和直角邊為x 那麼可以推出 y=(√2)*x ).
  

原理:正方形你可以看著是由兩個三角形拼接而成.正方形任意三點組合成等邊直接三角形.

這個比較簡單我就不列出程式碼了.可以利用數學向量的思想

• 思路2:
  四個點組成6個線段,四個線段長度相等(正方形邊長相等),另外兩個線段相同(正方形對角線垂直平分且長度相等),並且你還需要證明 兩個的線段長度 是四個線段的長度 根號2倍.
  為什麼還需要證明長度有根號2倍?.因為有可能是如下情況
  
  
  
  

圖片來自我的金同學

import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;



public class Main {

    //向量類 有些方法並沒有用到
    static  class MVector{

        Point startPoint;

        Point endPoint;

        Point vector;

        int
 
 unSqrtDistance;
        int x;
        int y;

        public MVector() {

        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
            vector=new Point(x, y);
            unSqrtDistance=x*x+y*y;
        }

        public
 
 MVector(Point startPoint, Point endPoint) {
            super();

            this.startPoint = startPoint;

            this.endPoint = endPoint;

            vector=new Point(endPoint.x-startPoint.x, endPoint.y-startPoint.y);

            x=vector.x;
            y=vector.y;

            unSqrtDistance=(int) ( Math.pow(endPoint.x-startPoint.x, 2)+Math.pow(endPoint.y-startPoint.y, 2)) ;
        }

        public static int mutiply(MVector p1,MVector p2){

            int result=p1.x*p2.x+p1.y*p2.y;

            return result;
        }

        //向量乘法
        public int mutiply(MVector p1){

            return mutiply(p1,this);
        }

        //兩個向量角度
        public static double getAngle(MVector p1,MVector p2){

            double resultCos=p1.mutiply(p2)/Math.sqrt((p1.unSqrtDistance*p2.unSqrtDistance));

            return Math.acos(resultCos);

        }
        public  double getAngle(MVector p2){


            return getAngle(this,p2);
        }
        public MVector(int x, int y) {
            super();
            this.x = x;
            setY(y);

        }


    }

    public static void main(String[] args) {


        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        boolean reulst[]= new boolean[n];

        int[]points=new int[4];
        MVector[] mVectors= new MVector[6];
        Point point[] = new Point[4];

        int flagDistance= Integer.MIN_VALUE;

        boolean[]  result=new boolean[n];


        for (int i = 0; i < n*2; i++) {

            for (int j = 0; j < 4; j++) {

                if((i&1)!=0){
                    point[j]=new Point(points[j], scanner.nextInt());
                }else{
                    points[j]=scanner.nextInt();
                }
            }

            //如果是輸入y
            if((i&1)!=0){

                //1-2   第一個點和第二個點組成向量
                mVectors[0] =new MVector(point[0],point[1]);

                //1-3
                mVectors[1] =new MVector(point[0],point[2]);

                //1-4
                mVectors[2] =new MVector(point[0],point[3]);

                //2-3
                mVectors[3] =new MVector(point[1],point[2]);

                //2-4
                mVectors[4] =new MVector(point[1],point[3]);

                //3-4
                mVectors[5] =new MVector(point[2],point[3]);

                //第一個長度
                int distance1=-1;
                //長度出現的次數
                int flag1=0;
                //同上
                int distance2=-1;
                int flag2=0;
                //注意向量長度為0的問題,如果兩個點相同.
                if (mVectors[0].unSqrtDistance>0) {
                    distance1=mVectors[0].unSqrtDistance;
                    flag1++;
                }



                //判斷6個邊 是否只有兩種長度 並且數量是4,另一個是2
                for (int j = 1; j < mVectors.length&&distance1!=-1; j++) {
                    if(mVectors[j].unSqrtDistance<=0){
                        break;  
                    }
                    else if(distance2==-1&&mVectors[j].unSqrtDistance!=distance1){
                        distance2=mVectors[j].unSqrtDistance;
                        flag2++;
                    }else if(mVectors[j].unSqrtDistance==distance1){
                        flag1++;
                    }else if (mVectors[j].unSqrtDistance==distance2) {
                        flag2++;
                    }else{
                        //出現第三個長度
                        break;
                    }
                }


                if ((flag1==4&&flag2==2)||(flag2==4&&flag1==2)) {
                    //長度根號倍 判斷.正方形的邊和對角線的平分 差兩倍,不要輕易算根號 不然丟精度 如根號5
                    if (distance1<<1==distance2||distance2<<1==distance1) {
                        result[(i-1)/2]=true;
                    }

                }
            }


        }

        System.out.println(Arrays.toString(result));

    }
}