矩阵运算

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

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