字典序问题

 问题描述：在数据加密和数据压缩中需要对特殊的字符串进行编码。给定的字母表由26个小写字母组成。该字母表产生的升序字符串是指字符串中字母从左到右出现的次序与字母在字母表中出现的次序相同，且每个字符最多出现1次。例如，a,b,ab,bc,xyz等都是升序字符串。现在对字母表中产生的所有长度不超过6的升序字符串按照字典序排列并编码如下：

1	2	...	26	27	28	...
a	b	...	z	ab	ac	...

    对于任意长度不超过6的升序字符中，迅速计算出它在上述字典中的编码。

    任务：对于给定的长度不超过6的升序字符串，编程计算它在上述字典中的编码。

    

解题思路：

    本题的关键之处在于正确理解题目描述中给出的字典序，其关键之处在于首先出现长度为1的字符串，然后是长度为2的字符串、……。而在相同长度的字符串中，按照字典序进行。例如，对字符串cfkp这个长度为4的字符串来讲，如果能够计算出排在它前面的字符串数目，加1就得到该字符串的编码。排列在该字符串前的字符串可以如下分析：

    （1）长度为1的字符串、长度为2的字符串、长度为3的字符串；

     (2）在以字母c打头的长度为4的字符串中，以cd、ce打头、长度为4的字符串同样排列在该字符串前面；而在以cf打头的长度为4的字符串中，以cfg、cfh、cfi、cfj打头的长度为4的字符串排列在该字符串前面；在以cfk打头的字符串中，以cfkl、cfkm、cfkn、cfko打头的长度为4的字符串同样在它前面。

    对第（2）种情况进行分析，可以分为如下几种情况：

    以cd和ce打头、长度为4的字符串数目与以d、e打头、长度为3的字符串数目相同；其他情况可以描述为：以g、h、i、j打头，长度为2的字符串数目；以l、m、n、o打头、长度为1的字符串数目。

    分析上述情况，对其中的规律进行总结，需要计算的字符串数目可以分为两类：

   （1）长度为k的字符串数目，用g(k)表示；

   （2）以字符ch打头，长度为k的字符串数目，用count1(ch,i)表示。

    显然，有

               count2(k)=sum_{ch=1}^26 count1(ch,k)

    同样，有如下规律可以发现：

               count1(ch,1)=1

               count1(ch,k)=sum_{i=ch+1}^26 count1(i,k-1)            

             

    在此基础上，可以计算出每个字符串的编码。

参考程序如下：

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


public class Section1_2_1 {


/**
* TODO
* 
* @author LiuYong
* @version 2013-9-3 下午2:52:17
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入要比较的字符串");
String s = "";
s = scan.next();
int sum1 = 0;
if (s.length() > 6 || s.equals("") || s.length() == 0) {
System.out.println("输入的字符串长度应该不得超过6");
} else {
Sum sum = new Sum();
Classify c = new Classify();
List<Classify> list = new ArrayList<Classify>();
list = c.Sort(s);
System.out.println(sum.sum1(list)+"  " + sum.sum2(list)+"  " +sum.sum3(list));
sum1 = sum.sum1(list) + sum.sum2(list) + sum.sum3(list);
System.out.println(sum1);
}


}
}


/**
 * 对输入的字符串进行处理，将每个字母作为一个对象看待
 * @author LiuYong
 * @version 2013-9-4  上午10:34:37
 */
class Classify {
int length = 0;// 长度，用于进行for循环
double sum = 0;// 数量
int num = 0;// 首字母编号，通过map来处理
List<Classify> list;
//无参构造函数
public Classify() {


}
//有参构造函数
public Classify(int len, int num) {
this.length = len;
this.num = num;
}


/**
* 将字符串中每个字母作为一个对象封装到链表中返回，将每个字母的编码位置（即1-26）、后续字符串的长度
* 记录下来作为对象的属性。
* 
* 
* @author LiuYong
* @version 2013-9-2 下午1:41:52
*/
public List<Classify> Sort(String st) {
list = new ArrayList<Classify>();
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 1; i <= 26; i++) {
map.put((char) (97 + i - 1), i);// 用于判断a——z26个字母的位置即编码（1-26），此处通过键值对一一对应
}
char[] ch = new char[st.length()];//创建一个长度为字符串长度的字符数组
for (int i = 0; i < st.length(); i++) {
ch[i] = st.charAt(i);//将对应位置的字符放进数组中
Classify cla = new Classify(st.length() - i-1, map.get(ch[i]));
list.add(cla);
}
return list;
}
}


/**
 * 核心计算类
 * @author LiuYong
 * @version 2013-9-4  上午10:44:36
 */
class Deal {


/**
* 计算字母k打头长度不超过len的字符串个数
* 
* @author LiuYong
* @version 2013-9-3 下午3:48:11
*/
public int count1(int i, int len) {
if (len == 1)
return 1;
else {
int sum = 0;
int j;
for (j = i + 1; j <= 26; j++) {
sum += count1(j, len - 1);
}
return sum;
}
}


/**
* 计算长度不超过len的字符串个数
* 
* @author LiuYong
* @version 2013-9-3 下午3:50:35
*/
public int count2(int len) {
int sum = 0;
for (int i = 1; i <= 26; i++)
sum += count1(i, len);
return sum;
}


}


/**
 * 求和类
 * @author LiuYong
 * @version 2013-9-4  上午10:44:07
 */
class Sum {
Deal d = new Deal();


/**
* 求长度小于字符串长度的个数
* 
* @author LiuYong
* @version 2013-9-3 下午3:58:57
*/
public int sum1(List<Classify> list) {
int sum = 0;
for (int i = 1; i < list.size(); i++) {
sum += d.count2(i);
}
return sum;
}


/**
* 长度为字符串长度但是在首字符之前的个数
* 
* @author LiuYong
* @version 2013-9-3 下午4:00:51
*/
public int sum2(List<Classify> list) {
int sum = 0;
for (int i = 1; i < list.get(0).num; i++) {
sum += d.count1(i, list.size());
}
return sum;
}


/**
* 首字母相同的且长度不超过字符串长度的
* @author LiuYong
* @version 2013-9-3  下午7:18:33
*/
public int sum3(List<Classify> list) {
int sum = 0;
for (int i = 1; i < list.size(); i++) {
int len = list.get(i - 1).length;
int temp1 = list.get(i - 1).num;
int temp2 = list.get(i).num;
for (int j = temp1 + 1; j < temp2; j++) {
sum += d.count1(j, len);
}
}
if(list.size()==1){
return sum;
}else{
return sum+1;
}
}
}