最大映射

有 n 个字符串，每个字符串都是由 A-J 的大写字符构成。现在你将每个字符映射为一个 0-9 的数字，不同字符映射为不同的数字。这样每个字符串就可以看做一个整数，唯一的要求是这些整数必须是正整数且它们的字符串不能有前导零。现在问你怎样映射字符才能使得这些字符串表示的整数之和最大？

输入描述:

每组测试用例仅包含一组数据，每组数据第一行为一个正整数 n ， 接下来有 n 行，每行一个长度不超过 12 且仅包含大写字母 A-J 的字符串。 n 不大于 50，且至少存在一个字符不是任何字符串的首字母。

输出描述:

输出一个数，表示最大和是多少。

输入例子:

2
ABC
BCA

输出例子:

1875

解析：通过每个字符分配权重来分配数字，比如出现的各位的分配1，十位的分配10，百位的分配100，以此类推，注意求出每个字母的权重后，要逐一扫描每个字母是否出现在某个字符串的开头，如果分配为0的字母做了某个字符串的开头，则需要找到权值最小的且没有做过某个字符串开头的字母，将他赋予0，其他的依次往上移动。

代码如下：

package com.itheima.WanMeiShiJie;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;


class Table{
 public char s;
 public long weight;
 public boolean isshow;
	public Table(char s1,long w)
	{
		this.s=s1;
		this.weight=w;
		this.isshow=false;
	}
	
}
public class Test1 {
    
	public static long calc(String s,Table[] t)
	{
		   StringBuilder result=new StringBuilder();
		  for(int i=0;i<s.length();i++)
		  {
			  int index=find(s.charAt(i),t);
			  if(index!=-1)
			  {
		         result.append(9-index);
				  
			  }
			  
		  }   
		return Long.parseLong(result.toString());
	}
	public static int find(char c, Table[] t)
	{
		for(int i=0;i<t.length;i++)
		{
			if(c==t[i].s)
			{
				return i;
			}
			
		}
		return -1;
	}
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()){
		int n=sc.nextInt();
		sc.nextLine();
		String[] s=new String[n];
		for(int i=0;i<s.length;i++)
		{
			s[i]=sc.nextLine();
			
		}
        Table[] table=new Table[10];
        for(int i=0;i<table.length;i++)
        {
        	table[i]=new Table((char)(65+i),0);
        }
		for(int i=0;i<n;i++)
		{     
			for(int j=0;j<s[i].length();j++)
			{
				
				switch(s[i].charAt(j))
				{
				case 'A':table[0].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'B':table[1].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'C':table[2].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'D':table[3].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'E':table[4].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'F':table[5].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'G':table[6].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'H':table[7].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'I':table[8].weight+=Math.pow(10,s[i].length()-j-1);
				break;
				case 'J':table[9].weight+=Math.pow(10,s[i].length()-j-1);
				break;	
				
				}
				
				
			}
		}
	
	Arrays.sort(table, new Comparator<Table>(){
		
		@Override
		public int compare(Table o1, Table o2) {
			if(o1.weight>o2.weight)
			return -1;
			else if(o1.weight<o2.weight)
				return 1;
			else
				return 0;
		}

	});
	
	for(int i=0;i<table.length;i++)
	{
		for(int j=0;j<n;j++)
		{
			if(table[i].s==s[j].charAt(0))
			{
				table[i].isshow=true;
			}
		}
		
	}
	
	if(table[9].isshow==true)
	{  
		int pos=0;
		for(int j=8;j>=0;j--)
		{
			if(table[j].isshow==false)
			{
				pos=j;
				break;
			}
		}
  /*    Table temp;
      temp=table[pos];
      table[pos]=table[9];
	  table[9]=temp;*/
	Table temp=new Table(table[pos].s,table[pos].weight);
	for(int k=pos+1;k<=9;k++)
	{
		table[k-1]=table[k];
	}
	table[9]=temp;	
	}
	
   /*for(int i=0;i<table.length;i++)
   {
	   System.out.println(table[i].s+"-->"+table[i].weight);
	   
   }*/
	
    long sum=0;
    
    for(int i=0;i<n;i++)
    {
    sum=sum+calc(s[i],table);		
    }
	
	System.out.println(sum);
	}	
	}
}