三、行相等的最少多米诺旋转（Weekly Contest 127）

最新推荐文章于 2022-03-20 11:28:24 发布

hello kitty w

最新推荐文章于 2022-03-20 11:28:24 发布

阅读量141

点赞数

CC 4.0 BY-SA版权

分类专栏：竞赛

本文链接：https://blog.csdn.net/qq_34446716/article/details/88386031

竞赛专栏收录该内容

253 篇文章

订阅专栏

本文通过对比两种不同的代码实现方式，展示了如何优化算法并简化代码。通过对原始冗余代码的分析，提出了一种更为简洁高效的算法实现，旨在帮助读者理解算法优化的重要性及其实现方法。

题目描述：
在这里插入图片描述

当时因为竞赛没有太多考虑，直接用最笨的方法来写的，代码比较冗余

class Solution {
    public int minDominoRotations(int[] A, int[] B) {
        //如果A里面的都相等，直接返回0
		 int first = A[0];
		 boolean iseq = true;
		 for (int i : A) {
			if(i != first){
				iseq = false;
				break;
			}
		}
		 if(iseq){
			 return 0;
		 }
		 //要想找到最小的那么首先需要找到出现次数最多的数字
		 Map<Integer, Integer> map = new TreeMap<>();
		 for (int i : A) {
			map.put(i, map.getOrDefault(i, 0) + 1);
		}
	  
		 
		//这里将map.entrySet()转换成list
	        List<Map.Entry<Integer ,Integer>> list = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
	        //然后通过比较器来实现排序
	        Collections.sort(list,new Comparator<Map.Entry<Integer,Integer>>() {
	        	@Override
	        	//升序排序
				public int compare(java.util.Map.Entry<Integer, Integer> o1, java.util.Map.Entry<Integer, Integer> o2) {
					return o2.getValue().compareTo(o1.getValue());
				}
	        });
	        int result = Integer.MAX_VALUE;
	        for(java.util.Map.Entry<Integer, Integer> mapping:list){ 
	        	boolean flag = true;
	        	int min = 0;
	               System.out.println(mapping.getKey()+":"+mapping.getValue()); 
	               for (int i = 0; i < A.length; i++) {
					if(A[i] != mapping.getKey()){
						if(B[i] != mapping.getKey()){
							flag = false;
							break;
						}else {
							min ++;
							
						}
					}
				}
	               if(flag){
	            	   if(min != 0){
	            		   result = Math.min(min, result);
	            	   }
	               }
	          } 
	     if(result == Integer.MAX_VALUE){
	    	  return -1;
	      }
	      //看B的值
	    //要想找到最小的那么首先需要找到出现次数最多的数字
			 Map<Integer, Integer> mapB = new TreeMap<>();
			 for (int i : B) {
				mapB.put(i, mapB.getOrDefault(i, 0) + 1);
			}
		  	//这里将map.entrySet()转换成list
		        List<Map.Entry<Integer ,Integer>> listB = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
		        //然后通过比较器来实现排序
		        Collections.sort(listB,new Comparator<Map.Entry<Integer,Integer>>() {
		        	@Override
		        	//升序排序
					public int compare(java.util.Map.Entry<Integer, Integer> o1, java.util.Map.Entry<Integer, Integer> o2) {
						return o2.getValue().compareTo(o1.getValue());
					}
		            
		        });
		       
		        int resultB = Integer.MAX_VALUE;
		        
		        for(java.util.Map.Entry<Integer, Integer> mapping:listB){ 
		        	boolean flag = true;
		        	int min = 0;
		               System.out.println(mapping.getKey()+":"+mapping.getValue()); 
		               for (int i = 0; i < B.length; i++) {
						if(B[i] != mapping.getKey()){
							if(A[i] != mapping.getKey()){
								flag = false;
								break;
							}else {
								min ++;
								
							}
						}
					}
		               if(flag){
		            	   if(min != 0){
		            		   resultB = Math.min(min, resultB);
		            	   }
		               }
		          } 
		       return Math.min(result, resultB);
    }
}

可以说很冗余了
看看这个代码：
有待学习

class Solution {
    public int minDominoRotations(int[] A, int[] B) {
        int min= A.length;
        for(int n=1; n<=6;n++){
            int Acount=0, Bcount=0;
            boolean flag = true;
            for (int i=0; i<A.length; i++){
                if (A[i]!=n && B[i]!=n){
                    flag=false;
                    break;
                }else {
                    if (A[i]==n){
                        Acount++;
                    }
                    if (B[i]==n){
                        Bcount++;
                    }
                }
            }
            if (flag){
                int Max = Math.max(Acount,Bcount);
                if (A.length-Max < min){
                    min=A.length-Max;
                }
            }
        }
        if (min!=A.length){
            return min;
        }
        return -1;
    }
}