1.   成语纠错

问题背景

你的任务是给一个错误的四字成语进行纠错,找到它的正确写法。具体来说,你只允许修改四个汉字中的其中一个,使得修改后的成语在给定的成语列表中出现。原先的错误成语保证不在成语列表中出现。

有时,这样的纠错结果并不惟一。例如一糯千金可以改为一字千金也可以改成一诺千金。但由于是同音字,一糯千金实为一诺千金的可能性比较大。

因此,我们还将提供一个汉字分类表,要求修改前后的两个字必须属于同一个分类。

在这样的限制下,我们保证成语纠错的结果惟一。

注意

1、汉字均采用GBK编码(参见FAQ)

2、每个汉字分类至少包含两个汉字,同一个汉字可能出现在多个类别中。

3、成语列表中的成语都是真实存在的四字成语。成语列表和待纠错成语中的所有汉字均在汉字分类表中的至少一个分类中出现。

输入格式

输入第一行包含两个整数n,m(1<=n<=200,1<=m<=20000)n表示汉字类别的个数,m表示成语的个数。

以下n行每行用一个无空白分隔符(空格、TAB)的汉字串表示一个分类中的所有汉字。注意,该汉字串最多可能包含200个汉字。

以下m行为成语列表,每行一个成语,恰好四个汉字。

最后一行为待纠错的成语,恰好四个汉字,且不在成语列表中出现。

输出格式

仅一行,为一个四字成语。在修改必须在同一分类中进行的限制下,输入数据保证纠错结果惟一。

样例输入

7    3

糯诺挪喏懦

字自子紫籽

前钱千牵浅

进近今仅紧金斤尽劲

完万

水睡税

山闪衫善扇杉

一诺千金

一字千金

万水千山

一糯千金

样例输出

一诺千金

  1. import java.io.IOException;  
  2. import java.util.ArrayList;  
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5.  
  6. /**  
  7.  *   
  8.  * @author phinecos  
  9.  * @since 2009-05-22  
  10.  *  
  11.  */ 
  12. public class Test   
  13. {  
  14.     private static List<String> catelogs = new ArrayList<String>();  
  15.     private static List<String> phrases = new ArrayList<String>();  
  16.       
  17.     public static int isValidPhrase(String strTested,String strBase)  
  18.     {//判断此成语是否与基准字符串只差一个字,若是,则返回此索引,否则返回-1  
  19.         int i,count = 0,pos = -1;  
  20.         for (i = 0; i < strBase.length(); ++i)  
  21.         {  
  22.             if (strBase.charAt(i) != strTested.charAt(i))  
  23.             {  
  24.                 ++count;  
  25.                 pos = i;  
  26.             }  
  27.         }  
  28.         if (count == 1)  
  29.         {//仅一字之差  
  30.             return pos;  
  31.         }  
  32.         else 
  33.         {  
  34.             return -1;  
  35.         }  
  36.     }  
  37.     public static boolean isSameCatelog(char chTested,char chBase)  
  38.     {//测试两个汉字是否在同一个类别下  
  39.         for (String catelog : catelogs)  
  40.         {  
  41.             if ((catelog.indexOf(chBase) != -1) && (catelog.indexOf(chTested) != -1))  
  42.             {//两个汉字在同一个类别下  
  43.                 return true;  
  44.             }  
  45.         }  
  46.         return false;  
  47.     }  
  48.     public static String correctPhrase(String wrongPhrase)  
  49.     {//纠正错误  
  50.         int pos;  
  51.         Iterator<String> iter = phrases.iterator();  
  52.         char chBase,chTested;  
  53.         String result = "";  
  54.         while (iter.hasNext())  
  55.         {  
  56.             String phrase = iter.next();//取成语表中当前成语  
  57.             pos = isValidPhrase(wrongPhrase, phrase);  
  58.             if ( pos != -1)  
  59.             {//与成语表中当前成语仅一字之差  
  60.                 chBase = phrase.charAt(pos);  
  61.                 chTested = wrongPhrase.charAt(pos);  
  62.                 if (isSameCatelog(chTested, chBase) == true)  
  63.                 {//在同一个类别下,可以进行修改  
  64.                     StringBuilder sb = new StringBuilder(wrongPhrase);  
  65.                     sb.setCharAt(pos, chBase);  
  66.                     result = sb.toString();  
  67.                     break;  
  68.                 }  
  69.             }  
  70.         }  
  71.         return result;  
  72.     }  
  73.     public static void main(String[] args) throws IOException  
  74.     {  
  75.         int n,m,i;  
  76.         java.util.Scanner scanner = new java.util.Scanner(System.in);  
  77.         //读入n,m,(1<=n<=200,1<=m<=20000)。n表示汉字类别的个数,m表示成语的个数。  
  78.         n = scanner.nextInt();  
  79.         m = scanner.nextInt();  
  80.               
  81.         //汉字分类表,每个分类中最多包含200个汉字  
  82.         for (i = 0; i < n; ++i)  
  83.         {  
  84.             catelogs.add(scanner.next());  
  85.         }  
  86.         //成语列表  
  87.         for (i = 0; i < m; ++i)  
  88.         {  
  89.             phrases.add(scanner.next());  
  90.         }  
  91.         //输入待纠错成语  
  92.         String wrongPhrase = scanner.next();  
  93.         //输出纠错后成语  
  94.         System.out.println(correctPhrase(wrongPhrase));  
  95.     }  
  96. }  
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 
 * 
@author phinecos
 * 
@since 2009-05-22
 *
 
*/
public class Test 
{
    
private static List<String> catelogs = new ArrayList<String>();
    
private static List<String> phrases = new ArrayList<String>();
    
    
public static int isValidPhrase(String strTested,String strBase)
    {
//判断此成语是否与基准字符串只差一个字,若是,则返回此索引,否则返回-1
        int i,count = 0,pos = -1;
        
for (i = 0; i < strBase.length(); ++i)
        {
            
if (strBase.charAt(i) != strTested.charAt(i))
            {
                
++count;
                pos 
= i;
            }
        }
        
if (count == 1)
        {
//仅一字之差
            return pos;
        }
        
else
        {
            
return -1;
        }
    }
    
public static boolean isSameCatelog(char chTested,char chBase)
    {
//测试两个汉字是否在同一个类别下
        for (String catelog : catelogs)
        {
            
if ((catelog.indexOf(chBase) != -1&& (catelog.indexOf(chTested) != -1))
            {
//两个汉字在同一个类别下
                return true;
            }
        }
        
return false;
    }
    
public static String correctPhrase(String wrongPhrase)
    {
//纠正错误
        int pos;
        Iterator
<String> iter = phrases.iterator();
        
char chBase,chTested;
        String result 
= "";
        
while (iter.hasNext())
        {
            String phrase 
= iter.next();//取成语表中当前成语
            pos = isValidPhrase(wrongPhrase, phrase);
            
if ( pos != -1)
            {
//与成语表中当前成语仅一字之差
                chBase = phrase.charAt(pos);
                chTested 
= wrongPhrase.charAt(pos);
                
if (isSameCatelog(chTested, chBase) == true)
                {
//在同一个类别下,可以进行修改
                    StringBuilder sb = new StringBuilder(wrongPhrase);
                    sb.setCharAt(pos, chBase);
                    result 
= sb.toString();
                    
break;
                }
            }
        }
        
return result;
    }
    
public static void main(String[] args) throws IOException
    {
        
int n,m,i;
        java.util.Scanner scanner 
= new java.util.Scanner(System.in);
        
//读入n,m,(1<=n<=200,1<=m<=20000)。n表示汉字类别的个数,m表示成语的个数。
        n = scanner.nextInt();
        m 
= scanner.nextInt();
            
        
//汉字分类表,每个分类中最多包含200个汉字
        for (i = 0; i < n; ++i)
        {
            catelogs.add(scanner.next());
        }
        
//成语列表
        for (i = 0; i < m; ++i)
        {
            phrases.add(scanner.next());
        }
        
//输入待纠错成语
        String wrongPhrase = scanner.next();
        
//输出纠错后成语
        System.out.println(correctPhrase(wrongPhrase));
    }
}

2,公平数

问题背景

如果一个整数的十六进制表示(不含前导0)中,前一半数字之和等于后一半数字之和,我们称它为公平数。

注意,如果该数的十六进制表示中包含奇数个数字,则正中间的数字既不属于前一半,又不属于后一半。

例如在十六进制下1+D=7+7,因此1DE77是公平数。数字E并不参与计算。

再例如,所有单个数字的十六进制数(即0~F)均为公平数,但F0不是(不能把F0补充前导0写成0F0,进而认为它是公平数)。

给出十六进制数 K, X, Y 和十六进制数字集合 S,求区间[X, Y]之内,有多少个公平数满足:

十六进制表达式(不包含前导0)中每个数字均在集合S

并且为K的倍数

输入格式

输入第一行为数字集S,包含0~9以及大写字母A~F

每个数字或字母最多出现一次。

第二行包含 3 个十六进制正整数K, X, Y,均不超过 10 个数字(包含0~9以及大写字母A~F,不包含前导 0)。

输出格式

仅一行,包含一个整数,即满足条件的公平数个数(10进制)。

样例输入

124C

5 100 FFF

样例输出

4

样例解释

只有四个数满足条件:2124244C4C1C

  1. /************************************************************************/ 
  2. /* Author: phinecos Date:2009-05-22                                                                     */ 
  3. /************************************************************************/ 
  4. #include <iostream>  
  5. using namespace std;  
  6.  
  7. char s[17]={0};//十六进制数字集合S  
  8. long k,x,y;//十六进制数X,Y,K  
  9.  
  10. void charupper(char *string)  
  11. {  
  12.     int i;  
  13.  
  14.     for(i=0;i<strlen(string);i++)  
  15.     {  
  16.         if(string[i]>='a' && string[i]<='z')  
  17.             string[i] -='a'-'A';  
  18.     }  
  19. }  
  20.  
  21. bool checksinglechar(char ch)  
  22. {  
  23.     int i;  
  24.  
  25.     for(i=0;i<strlen(s);i++)  
  26.         if(s[i] == ch)  
  27.             return true;  
  28.  
  29.     return false;  
  30. }  
  31.  
  32. bool isAllInSet(long num)  
  33. {  
  34.     char tstring[12];  
  35.     int i;  
  36.  
  37.     sprintf(tstring,"%lx",num);  
  38.     charupper(tstring);  
  39.  
  40.     for(i=0;i<strlen(tstring);i++)  
  41.     {  
  42.         if(checksinglechar(tstring[i])==false)  
  43.             return false;  
  44.     }  
  45.     return true;  
  46. }  
  47.  
  48. int convert(char ch)  
  49. {  
  50.     if(ch>='a' && ch<='f')  
  51.     {  
  52.         return (ch-'a'+10);  
  53.     }  
  54.     else if(ch>='A' && ch<='F')  
  55.     {  
  56.         return (ch-'A'+10);  
  57.     }  
  58.     else if(ch>='0' && ch<='9')  
  59.     {  
  60.         return (ch-'0');  
  61.     }  
  62.     else 
  63.         return 0;  
  64. }  
  65.  
  66. bool isFairNum(long num)  
  67. {//检查是否是公平数  
  68.     char tstring[100]={0};  
  69.     int bsum=0,lsum=0;  
  70.     int i;  
  71.  
  72.     ltoa(num,tstring,16);//转换为进制  
  73.  
  74.     if(strlen(tstring)%2==0)  
  75.     {//若长度为偶数,比较前一半数字之和与后一半数字之和  
  76.         for(i=0;i<strlen(tstring)/2;i++)  
  77.             bsum+=convert(tstring[i]);  
  78.         for(i=strlen(tstring)/2;i<strlen(tstring);i++)  
  79.             lsum+=convert(tstring[i]);  
  80.         if(bsum==lsum)  
  81.         {  
  82.             return true;//是公平数  
  83.         }  
  84.         else 
  85.         {  
  86.             return false;  
  87.         }  
  88.     }  
  89.     else 
  90.     {//若长度为奇数,忽略掉中间的数字  
  91.         for(i=0;i<strlen(tstring)/2;i++)  
  92.             bsum+=convert(tstring[i]);  
  93.         for(i=strlen(tstring)/2+1;i<strlen(tstring);i++)  
  94.             lsum+=convert(tstring[i]);  
  95.         if(bsum==lsum)  
  96.         {  
  97.             return true;//是公平数  
  98.         }  
  99.         else 
  100.         {  
  101.             return false;  
  102.         }  
  103.     }  
  104. }  
  105.  
  106. int main()  
  107. {  
  108.     cin>>s;  
  109.     cin>>hex>>k>>x>>y;  
  110.  
  111.     long nCount =0;//符合条件的数字个数  
  112.  
  113.     for (long num = x; num <= y; ++num)  
  114.     {  
  115.         if ((num%k) == 0)  
  116.         {//是k的倍数  
  117.             if(isFairNum(num) == true)  
  118.             {//是公平数  
  119.                 if(isAllInSet(num) == true)  
  120.                 {//检查十六进制表达式(不包含前导)中每个数字是否均在集合S中  
  121.                     ++nCount;  
  122.                 }  
  123.             }  
  124.         }  
  125.  
  126.     }  
  127.     cout << nCount << endl;  
  128.     return 0;