修理桌子-Java

  Arthur最近搬到了新的别墅，别墅特别大，原先的桌子显得比较小，所以他决定换一张新的桌子。他买了一张特别大的桌子，桌子是由很多条桌腿进行支撑的，可是回到家之后他发现桌子不稳，原来是桌子腿长度不太相同。他想要自己把桌子修理好，所以他决定移除掉一些桌腿来让桌子变得平稳。桌子腿总共有n条腿，第i条腿长度为li，Arthur移除第i桌腿要花费代价为di。假设k条腿桌子平稳的条件:超过一半桌腿能够达到桌腿长度的最大值。例如：一条腿的桌子是平稳的，两条腿的桌子腿一样长时是平稳的。请你帮Arthur计算一下是桌子变平稳的最小总代价。

输入描述：

输入：

        第一行数据是一个整数：n(1<=n<=105)，n表示桌腿总数。

        第二行数据是n个整数：l1，l2，...，ln(1<=li<=105)，表示每条桌腿的长度。

        第三行数据是n个整数：d1，d2，...，dn(1<=di<=200)，表示移除每条桌腿的代价

输出描述：

输出：

       输出让桌子变平稳的最小总代价

输入例子

               6

               2 2 1 1 3 3

               4 3 5 5 2 1

输出例子

8

注：牛客网测试用例不全，即使通过也可能是错的。

思路：把输入的腿长映射到一个106维的腿长数目数组，数组的值为对应腿长的数目，然后依次遍历数组中的值作为最长的桌腿长度，计算其代价，最后选择最小的代价。

举个例子

               6

               2 2 1 1 3 3

               4 3 5 5 2 1

1、保留a[3]作为最大桌腿长度，从而即在剩下的n-m条桌腿中保留代价最大的m-1条，移除其余的n-m-(m-1)条代价最小的桌腿，在该例中从2 2 1 1中选择代价为4，3，5的移除，代价为12

2、保留a[2]作为最大桌腿长度，那么要去除桌腿长度为3的，代价为5，再在剩下的2条桌腿中保留代价最大的m-1=2-1=1条，移除其余的n-m-(m-1)条代价最小的桌腿，在该例中从1 1中选择代价为5的移除，总代价为8

故最小的代价为8.

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {       
         int n;        
         int minCount=0;
         Scanner in=new Scanner(System.in);
         ArrayList<Integer> li = new ArrayList<Integer>();
         ArrayList<Integer> di = new ArrayList<Integer>();         
         int[] a = new int[106]; 
            n=in.nextInt();
            for(int i=0;i<n;i++){
            	int temp=in.nextInt();
            	li.add(temp);
            	a[temp]+=1;
            }            
            for(int i=0;i<n;i++){
            	int tmp=in.nextInt();
            	di.add(tmp);
            	minCount+=tmp;
            }
            for(int i=105;i>0;i--){
                int cost=0;
                ArrayList<Integer> cut = 
                	new ArrayList<Integer>();
                if(a[i]>0){
                	
                	if(a[i]*2<=n){
                		 int cutNum = li.size()-a[i];
                         for(int j=i+1;j<106;j++){
                             cutNum-=a[j];
                         }
                         cutNum-=(a[i]-1);
                       
                         for(int k=0;k<li.size();k++){
                             if(li.get(k)<i){
                                 cut.add(di.get(k));
                             }
                             if(li.get(k)>i){
                                 cost+=di.get(k);
                             }
                         }
                         if(cut.size()>0){
                             if(cutNum<=0){
                                 cutNum=0;
                             }
                             Collections.sort(cut);
                             for(int k=0;k<cutNum;k++){
                                 cost+=cut.get(k);
                             }
                             if(cost<minCount){                              	
                                 minCount=cost;
                             }  
                         }
                	}else{                		                	
                		  for(int k=0;k<li.size();k++){                           
                              if(li.get(k)>i){                           	  
                                  cost+=di.get(k);                                 
                              }                            
                          }               		                 		 
                	}
                	 if(cost<minCount){
                        	
                         minCount=cost;
                     }               
                }
            }          
            System.out.println(minCount);      
    }
}