矩形运算

在编写图形界面软件的时候，经常会遇到处理两个矩形的关系。


    如图【1.jpg】所示，矩形的交集指的是：两个矩形重叠区的矩形，当然也可能不存在（参看【2.jpg】）。两个矩形的并集指的是：能包含这两个矩形的最小矩形，它一定是存在的。
（1.jpg）(2.jpg)

    本题目的要求就是：由用户输入两个矩形的坐标，程序输出它们的交集和并集矩形。


    矩形坐标的输入格式是输入两个对角点坐标，注意，不保证是哪个对角，也不保证顺序（你可以体会一下，在桌面上拖动鼠标拉矩形，4个方向都可以的）。


    输入数据格式：
x1,y1,x2,y2
x1,y1,x2,y2
    
    数据共两行，每行表示一个矩形。每行是两个点的坐标。x坐标在左，y坐标在右。坐标系统是：屏幕左上角为(0,0)，x坐标水平向右增大；y坐标垂直向下增大。


    要求程序输出格式：
x1,y1,长度,高度
x1,y1,长度,高度


    也是两行数据，分别表示交集和并集。如果交集不存在，则输出“不存在”


    前边两项是左上角的坐标。后边是矩形的长度和高度。


    例如，用户输入：
100,220,300,100
150,150,300,300


    则程序输出：
150,150,150,70
100,100,200,200


    例如，用户输入：
10,10,20,20
30,30,40,40


    则程序输出：
不存在
10,10,30,30

 

import java.util.Scanner;

public class ys_08 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		String firstRR=scanner.nextLine();
		String secondRR=scanner.nextLine();
		new ys_08().new answer(firstRR,secondRR);
	}
	public class answer{
		private RR left;//相对位于左边的矩形
		private RR right;//相对位于右边的矩形
		public answer(String firstRR,String secondRR){
			int[] temp1=new int[4];
			int[] temp2=new int[4];
			//先定义四个点
			PP p1,p2,p3,p4;
			String[] r1s=firstRR.split(",");
			for(int i=0;i<r1s.length;i++){
				temp1[i]=Integer.valueOf(r1s[i]);
			}
			int min1=0;
			if(temp1[0]>temp1[2]){
				//左边的点
				p1=new PP(temp1[2],temp1[3]);
				//右边的点 
				p2=new PP(temp1[0],temp1[1]);
				min1=temp1[2];
			}else{
				//左边的点
				p1=new PP(temp1[0],temp1[1]);
				//右边的点 
				p2=new PP(temp1[2],temp1[3]);
				min1=temp1[0];
			}
			String[] r2s=secondRR.split(",");
			for(int i=0;i<r2s.length;i++){
				temp2[i]=Integer.valueOf(r2s[i]);
			}
			int min2=0;
			if(temp2[0]>temp2[2]){
				//左边的点
				p3=new PP(temp2[2],temp2[3]);
				//右边的点 
				p4=new PP(temp2[0],temp2[1]);
				min2=temp2[2];
			}else{
				//左边的点
				p3=new PP(temp2[0],temp2[1]);
				//右边的点 
				p4=new PP(temp2[2],temp2[3]);
				min2=temp2[0];
			}
			if(min1<min2){
				//第一个矩阵有最小的x坐标
				left=new RR(p1,p2);
				right=new RR(p3,p4);
			}else{
				//第二个矩形有最小的x坐标
				left=new RR(p3,p4);
				right=new RR(p1,p2);
			}
			interSet();
			unionSet();		
		}
		public RR getLeft() {
			return left;
		}
		public void setLeft(RR left) {
			this.left = left;
		}
		public RR getRight() {
			return right;
		}
		public void setRight(RR right) {
			this.right = right;
		}
		//并集,X1,Y1,长度，宽度
		public void unionSet(){
			System.out.print(left.getLeftUP().getX()+",");
			int minY=0;
			if(left.getLeftUP().getY()<right.getLeftUP().getY()){
				minY=left.getLeftUP().getY();
				System.out.print(left.getLeftUP().getY()+",");
			}else{
				minY=right.getLeftUP().getY();
				System.out.print(right.getLeftUP().getY()+",");
			}
			if(left.getRightDown().getX()>right.getRightDown().getX()){
				System.out.print("长度为:"+(left.getRightDown().getX()-left.getLeftUP().getX())+",");
			}else{
				System.out.print("长度为:"+(right.getRightDown().getX()-left.getLeftUP().getX())+",");
			}
			if(left.getRightDown().getY()>right.getRightDown().getY()){
				System.out.println("高度为:"+(left.getRightDown().getY()-minY));
			}else{
				System.out.println("高度为:"+(right.getRightDown().getY()-minY));
			}
			
		}
		//交集
		public void interSet(){
		
			if(left.getRightDown().getX()<=right.getLeftUP().getX()||
				right.getRightDown().getY()<=left.getLeftUP().getY()||
				left.getRightDown().getY()<=right.getLeftUP().getY()){
				System.out.println("不存在");
				return;
			}
			//x坐标一定是右端坐标
			int x=right.getLeftUP().getX();
			int y=0;
			int length=0;
			int height=0;
			if(right.getLeftUP().getX()<left.getRightDown().getX()&&
				right.getLeftUP().getY()<left.getRightDown().getY()){
				y=right.getLeftUP().getY();
				//包含在内部
				if(left.getRightDown().getY()>=right.getRightDown().getY()){	
					height=right.getRightDown().getY()-right.getLeftUP().getY();
				}else{
					height=left.getRightDown().getY()-y;
				}
			}else{
				
				y=left.getLeftUP().getY();
				
				if(left.getRightDown().getY()>right.getRightDown().getY()){
					height=right.getRightDown().getY()-y;
				}else{
					//左矩形的宽度
					height=left.getRightDown().getY()-y;
				}
			}
			if((left.getRightDown().getX()-x)>=
					right.getRightDown().getX()-right.getLeftUP().getX()){
					length=right.getRightDown().getX()-right.getLeftUP().getX();
				}else{
					length=right.getRightDown().getX()-x;
			}
			System.out.println(x+","+y+","+"长度为:"+length+",宽度为:"+height);
			
		}	
	}
	//表示一个矩形
	public class RR{
		private PP leftUP;//左上角
		private PP rightDown;//右下角
		public PP getLeftUP() {
			return leftUP;
		}
		public void setLeftUP(PP leftUP) {
			this.leftUP = leftUP;
		}
		public PP getRightDown() {
			return rightDown;
		}
		public void setRightDown(PP rightDown) {
			this.rightDown = rightDown;
		}
		public RR(PP lu,PP rd){
			//保证矩形保存的点为左上角和右下角的点
			if(lu.getY()>rd.getY()){
				int temp=lu.getY();
				lu.setY(rd.getY());
				rd.setY(temp);
			}
			this.leftUP=lu;
			this.rightDown=rd;	
		}
	}
	//表示一个点
	public class PP{
		private int x;
		private int y;
		public PP(int x,int y){
			this.x=x;
			this.y=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;
		}
	}
}