NYOJ-圈水池(Java版)+凸包算法+冒泡

原创：原创https://mp.csdn.net/postedit/82973390未经允许请别转载

                                                           圈水池

                                                         时间限制：3000 ms  |  内存限制：65535 KB

                                                                                          难度：4

描述

有一个牧场，牧场上有很多个供水装置，现在牧场的主人想要用篱笆把这些供水装置圈起来，以防止不是自己的牲畜来喝水，各个水池都标有各自的坐标，现在要你写一个程序利用最短的篱笆将这些供水装置圈起来！（篱笆足够多，并且长度可变）

输入

第一行输入的是N,代表用N组测试数据（1<=N<=10）
第二行输入的是m,代表本组测试数据共有m个供水装置（3<=m<=100）
接下来m行代表的是各个供水装置的横纵坐标

输出

输出各个篱笆经过各个供水装置的坐标点，并且按照x轴坐标值从小到大输出，如果x轴坐标值相同，再安照y轴坐标值从小到大输出。

样例输入

1
4
0 0
1 1
2 3
3 0

样例输出

0 0
2 3
3 0

来源

[张洁烽]原创

上传者

张洁烽

我在网上看了看基本没有发现这道题的代码？

接下来直接上，已经AC了
如果有更好的建议或者更好的代码，如果发现错误，请留言，谢谢大家

 

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner sc =new Scanner(System.in);
		int n=sc.nextInt();

		for(int i=0;i<n;i++)
		{
			int m=sc.nextInt();
			Point point[]=new Point[m];
			for(int j=0;j<m;j++)
			{
				int x=sc.nextInt();
				int y=sc.nextInt();
				point[j]=new Point(x, y);
			}
			Point[] p=solution(point);
			result(p);

		}
	}

	private static void result(Point[] p) {
		// TODO 自动生成的方法存根
		int X[]=new int[p.length];
		int Y[]=new int[p.length];
		int [][]zz=new int[p.length][2];
		for(int i=0;i<p.length;i++)
		{
			for(int j=0;j<2;j++)
			{
				if(j==0)
					zz[i][j]=p[i].getX();
				if(j==1)
					zz[i][j]=p[i].getY();
			}
		}
		
		for(int i=0;i<p.length-1;i++)
		{//外层循环控制排序趟数
			for(int j=0;j<p.length-1-i;j++)
			{//内层循环控制每一趟排序多少次
				if(zz[j][0]>zz[j+1][0])
				{
					int tempx=zz[j][0];
					int tempy=zz[j][1];
					
					zz[j][0]=zz[j+1][0];
					zz[j][1]=zz[j+1][1];
					
					zz[j+1][0]=tempx;
					zz[j+1][1]=tempy;
				}
				if(zz[j][0]==zz[j+1][0])
				{
					if(zz[j+1][1]<zz[j][1])
					{
						int tempy=zz[j][1];
						
						zz[j][1]=zz[j+1][1];
						
						zz[j+1][1]=tempy;
					}
				}
			}
		} 


		for (int i = 0; i < zz.length; i++) {	
			for (int j = 0; j < 2; j++) {	
				System.out.print(zz[i][j]+" ");		
			}
			System.out.print("\n");
		}
	}

	private static Point[] solution(Point[] point) {
		int len=0;
		for(int i=0;i<point.length;i++)
		{
			for(int j=0;j<point.length;j++) 
			{
				if(i==j)
					continue;
				int judge[]=new int[point.length];
				for(int k=0;k<point.length;k++)
				{

					int a=point[j].getY()-point[i].getY();
					int b=point[i].getX()-point[j].getX();
					int c=point[i].getX()*point[j].getY()-point[j].getX()*point[i].getY();

					judge[k]=a*point[k].getX()+b*point[k].getY()-c;

				}
				if(isPoint(judge))
				{
					point[len++]=point[i];
					break;
				}

			}
		}
		Point point1[]=new Point[len];
		for(int k=0;k<len;k++)
		{
			point1[k]=point[k];
		}
		return point1;
	}

	private static boolean isPoint(int[] judge) {
		// TODO 自动生成的方法存根
		boolean ispoint = false;
		int len1 = 0, len2 = 0;

		for(int i = 0;i < judge.length;i++){
			if(judge[i] >= 0)
				len1++;
		}
		for(int j = 0;j < judge.length;j++){
			if(judge[j] <= 0)
				len2++;
		}

		if(len1 == judge.length || len2 == judge.length)
			ispoint = true;
		return ispoint;
	}


}
class Point  {

	private int x;
	private int y;

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	public Point(int x, int y) {
		// TODO 自动生成的构造函数存根
		this.x = x;
		this.y = y;
	}




}