矩阵运算

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

    如图【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

说明：

并集很简单，这里就不会说了，主要说交集，这里定义一个矩形通过左上角的X和Y坐标，以及右下角的X，Y坐标来确定，即对角线就能确定一个矩形位置，则分析如下:

只要保证了两个矩形的相对位置为左右，则交集的左上X一定等于右矩形的左上X值

当并集上边框等于右矩形上边框==》交集左上Y值等于左矩形左上Y值
当并集上边框等于左矩形上边框==》交集左上Y值等于右矩形左上Y值

当并集右边框等于左矩形右边框==》交集右下X值等于右矩形右下X值
当并集右边框等于右矩形右边框==》交集右下X值等于左矩形右下X值

当并集下边框等于左矩形下边框==》交集右下Y值等于右矩形右下Y值
当并集下边框等于右矩形下边框==》交集右下Y值等于左矩形右下Y值

java代码如下:

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;//相对位于右边的矩形
		int topY=0;
		int downY=0;
		int rightX=0;
		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);
			}
			unionSet();	
			interSet();
				
		}
		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()+",");
			if(left.getLeftUP().getY()<right.getLeftUP().getY()){
				topY=left.getLeftUP().getY();
				System.out.print(left.getLeftUP().getY()+",");
			}else{
				topY=right.getLeftUP().getY();
				System.out.print(right.getLeftUP().getY()+",");
			}
			
			if(left.getRightDown().getX()>right.getRightDown().getX()){
				rightX=left.getRightDown().getX();
				System.out.print("长度为:"+(left.getRightDown().getX()-left.getLeftUP().getX())+",");
			
			}else{
				rightX=right.getRightDown().getX();
				System.out.print("长度为:"+(right.getRightDown().getX()-left.getLeftUP().getX())+",");
			}
			if(left.getRightDown().getY()>right.getRightDown().getY()){
				downY=left.getRightDown().getY();
				System.out.println("高度为:"+(left.getRightDown().getY()-topY));
			}else{
				downY=right.getRightDown().getY();
				System.out.println("高度为:"+(right.getRightDown().getY()-topY));
			}
			
		}
		//交集
		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一定等于右矩形的左上X值
			int leftUpX=right.getLeftUP().getX();
			int leftUpY=0;
			if(topY==left.getLeftUP().getY()){
				leftUpY=right.getLeftUP().getY();
			}else{
				leftUpY=left.getLeftUP().getY();
			}
			int rightDownY=0;
			if(downY==left.getRightDown().getY()){
				rightDownY=right.getRightDown().getY();
			}else{
				rightDownY=left.getRightDown().getY();
			}
			int rightDownX=0;
			if(rightX==left.getRightDown().getX()){
				rightDownX=right.getRightDown().getX();
			}else{
				rightDownX=left.getRightDown().getX();
			}
			System.out.println("交集:"+leftUpX+","+leftUpY+",长度为:"+(rightDownX-leftUpX)+",高度为"+(rightDownY-leftUpY));
		}	
	}
	//表示一个矩形
	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;
		}
	}
}