2019阿里巴巴实习生客户端开发工程师Android编程题脏矩阵合并

记录一下今晚参加的2019阿里Android开发实习生一道编程题。
另一道连题目都没看懂，还浪费了好多时间qaq
这一道看懂题目后其实也不是很难吧，当时没时间了，匆忙中也弄错了一些细节，哎，早知道这么难就不参加了，何必呢…
话不多说上题目

题目：脏矩阵合并

为了记录这个题，截了好多张图，不要不信，看题目能把人吓一跳。看了半天都不知道这是个啥鬼题。

各位小伙伴你们体会一下吧~~~

图一

图二

图三

图四

图五

图六

图七

思路

怎么样？光看懂题目得半天吧，这还不保证能不能看懂QAQ

我理解的题意，一句话概括就是：矩阵合并，然后再计算面积。

那个单次渲染时间，就是一个的矩形面积s+10000，即 t = s + 10000
总渲染时间，就是所有合并后的矩形的渲染时间加起来。

代码

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Testss {

	 private static class Rect {
	        private int left;
	        private int top;
	        private int width;
	        private int height;
	    }
	public static void main(String[] args) {
		 Scanner in = new Scanner(System.in);
	        int n = Integer.parseInt(in.nextLine());
	        Rect[] rects = new Rect[n];
	        for (int i = 0; i < n; i++) {
	            rects[i] = new Rect();
	            rects[i].left = Integer.parseInt(in.nextLine());
	            rects[i].top = Integer.parseInt(in.nextLine());
	            rects[i].width = Integer.parseInt(in.nextLine());
	            rects[i].height = Integer.parseInt(in.nextLine());
	        }
	        System.out.println(String.valueOf(costTime(rects)));

	}
	/**
	 * 两个矩形是否能合并
	 * @param r1
	 * @param r2
	 * @return
	 */
	public static boolean isMerge(Rect r1,Rect r2){
		int right1 = r1.left+r1.width;//右
		int b1 = r1.top+r1.height;//下
		
		int right2 = r2.left+r2.width;//右
		int b2 = r2.top+r2.height;//下
		//一个矩阵在另一个矩阵的左上右下部分任何一个方位，就是没有交集，就是不能合并
		if(b2<r1.top && right2<r1.left || r2.top>b1 && right2<r1.left
				|| b2<r1.top && r2.left>right1 || r2.top>b1 && r2.left>right1
				){
			return false;
		}
		//否则有交集，能合并
		return true;
		
	}
	/**
	 * 合并两个矩形
	 * @param r1
	 * @param r2
	 * @return
	 */
	public static Rect merge(Rect r1,Rect r2){
		int right1 = r1.left+r1.width;
		int b1 = r1.top+r1.height;
		
		int right2 = r2.left+r2.width;
		int b2 = r2.top+r2.height;
		//合并成新的矩阵
		Rect r = new Rect();
		r.left = r1.left<r2.left?r1.left:r2.left;//左
		r.top = r1.top<r2.top?r1.top:r2.top;//上
		
		int right = right1>right2?right1:right2;//右
		int b = b1>b2?b1:b2;//下
		
		r.width = right-r.left;//宽
		r.height = b-r.top;//高
		
		return r;
		
	}
	
	
	private static long costTime(Rect[] rects) {
        int len = rects.length;
        if(len == 0) return 0;
        
        List<Rect> rec = new ArrayList<>();//暂存列表
        List<Rect> realRec = new ArrayList<>();//真正合并后的矩形
        rec.add(rects[0]);//先添加一个
        for(int i = 1;i<len;i++){
        	boolean isMerged = false;//标记是否合并了
        	//从暂存表中依次比较，看能否合并，
        	for(Rect re:rec){
        		boolean canM = isMerge(re,rects[i]);
        		if(canM){
        		//能删除当前的，并添加合并后的
        			rec.remove(re);
        			rec.add(merge(re,rects[i]));
        			isMerged = true;
        			break;
        		}
        	}
        	//如果出现一个不能合并的，就把暂存合并的矩形放到真正合并后的列表中
        	//开启一轮新的合并
        	if(!isMerged) {
        		//保存真正的合并后的矩形
        		realRec.addAll(rec);
        		//清空暂存列表
        		rec.clear();
        		//添加该不能合并的矩形，开启新的一轮合并
        		rec.add(rects[i]);
        	}
        }
        //添加最后一轮合并好的矩形
        if(rec.size()!=0){
        	realRec.addAll(rec);
        }
        //计算最终面积，结果
        int resu = 0;
		for(Rect r: realRec){
			resu+=r.width*r.height+10000;
		}
        return resu;
    }
}

也不知道对不对。。。
反正它给的那个用例测了下，结果是对的。

哎，做的不好…