我是这样分析的,代码没有去实现。一,考虑边界问题。
二,实现优化笛卡尔积组合,
例如:abcbcabc
1,纵向切:
得到所有字符串组合,注意:这里要求的是最多连续子字符串,其实就是优化笛卡尔积的原则,也是边界。以子串的长度为1开始切,且称为切:
从a开始切:
第一次切出a子字符串,得到: a和bcbcabc,暂且为切点a1,做标记。
第二次切出ab子字符串,得到: ab和cbcabc,暂且为切点a2,做标记。
依次类推到完。
再从b开始切:
第一次切出b子字符串,得到: b和cbcabc,暂且为切点b1,做标记。
第二次切出ab子字符串,得到: ab和cbcabc,暂且为切点b2,做标记。依次类推到完。再从c开始切:依次类推到完。2,横向比:
将a的所有切点按切的顺序保存到称为a集合数组中(且为数组吧)将b的所有切点按切的顺序保存到称为b集合数组中(且为数组吧)
依次类推到完。将a集合,b集合等全部集合横向比较,得到相同字符串记数最大值,即求出出现次数最多的子串。
比较方式:
正于前面所说,要求的是最多连续子字符串。其实就是优化笛卡尔积的原则,也是边界。所以我们要做的是将所有集合一对一比较,不是多对多或其他(更简单的理由:位数不同,无需比较)。
多位子字符串一对一比较时候,例如 ab属于a集合和b集合的bc比较,显然没有意义。需要跳跃比较(且这样说吧,呵呵)。跳跃是有规律的。很显然就不说了。
之所以纵切,是为了解决横比较带来的优化问题。总体我是这样想的:就是纵向切出字符串的连续组合集合,在横向比较集合。
不知道正确与否。仅供参考,呵呵或许参考价值都没有哦。还望高手给出答案。
二,实现优化笛卡尔积组合,
例如:abcbcabc
1,纵向切:
得到所有字符串组合,注意:这里要求的是最多连续子字符串,其实就是优化笛卡尔积的原则,也是边界。以子串的长度为1开始切,且称为切:
从a开始切:
第一次切出a子字符串,得到: a和bcbcabc,暂且为切点a1,做标记。
第二次切出ab子字符串,得到: ab和cbcabc,暂且为切点a2,做标记。
依次类推到完。
再从b开始切:
第一次切出b子字符串,得到: b和cbcabc,暂且为切点b1,做标记。
第二次切出ab子字符串,得到: ab和cbcabc,暂且为切点b2,做标记。依次类推到完。再从c开始切:依次类推到完。2,横向比:
将a的所有切点按切的顺序保存到称为a集合数组中(且为数组吧)将b的所有切点按切的顺序保存到称为b集合数组中(且为数组吧)
依次类推到完。将a集合,b集合等全部集合横向比较,得到相同字符串记数最大值,即求出出现次数最多的子串。
比较方式:
正于前面所说,要求的是最多连续子字符串。其实就是优化笛卡尔积的原则,也是边界。所以我们要做的是将所有集合一对一比较,不是多对多或其他(更简单的理由:位数不同,无需比较)。
多位子字符串一对一比较时候,例如 ab属于a集合和b集合的bc比较,显然没有意义。需要跳跃比较(且这样说吧,呵呵)。跳跃是有规律的。很显然就不说了。
之所以纵切,是为了解决横比较带来的优化问题。总体我是这样想的:就是纵向切出字符串的连续组合集合,在横向比较集合。
不知道正确与否。仅供参考,呵呵或许参考价值都没有哦。还望高手给出答案。
public class CountEachLetter{public static void main(String[] args){String s=JOptionPane.showInputDialog(null,"Enter a string:","Example 7.2
Input",JOptionPane.QUESTION_MESSAGE);int[] counts=countLetters(s.toLowerCase()); //忽略字母的大小写,所以使用toLowerCase方法.String output=" ";for(int i=0;i<counts.length;i++){if(counts[i]!=0)
output+=(char)('a'+1)+"appears"+
counts[i]+((counts[i]==1)?"time\n":"times\n");
}
JOptionPane.showMessageDialog(null,output,"Example 7.2 Output",JOptionPane.INFORMATION_MESSAGE);
}public static int[] countLetters(String s){ //countLetter方法是返回一个包含26个元素的数组,每个元素用来统计字符串s中对应字母出现的个数.
int[] counts=new int[26];
for(int i=0;i<s.length();i++){
if(Character.isLetter(s.charAt(i))) counts[s.charAt(i)-'a']++;
}
return counts;
}}
这段代码是在书上抄的,是计算字符串中每个字母出现了次数的,共同学习吧
int offset = 0;
int len = str.length();
for (int i = len / 2; i >0; i--) { while (offset + 2 * i <=len) {
if (str.substring(offset, offset + i).equals(
str.substring(offset + i, offset + 2 * i))) {
System.out.println(str.substring(offset, offset + i));
}
offset++;
}
offset=0; } } public static void main(String args[]) { String test = "adadcdadcd";
new test1().travese(test); }}
输出:
dadc
adcd
ad
二,实现优化笛卡尔积组合,
总体我是这样想的:就是纵向切出字符串的连续组合集合,在横向一对一跳跃比较集合元素。
例如:abcbcabc
一,纵向切:
得到所有字符串组合,注意:这里要求的是最多连续子字符串,其实就是优化笛卡尔积的原则,也是边界。
字符串共8位,以子串的长度为1,从字符串第一位开始切,且称为切:
1----从a开始切:(字符串为abcbcabc )
第一次切出a子字符串,得到: a和bcbcabc,
第二次切出ab子字符串,得到: ab和cbcabc,
第三次切出abc子字符串,得到: abc和bcabc,
第四次切出abcb子字符串,得到: abcb和cabc,
第五次切出abcbc子字符串,得到: abcbc和abc,
第六次切出abcbca子字符串,得到: abcbca和bc,
第七次切出abcbcab子字符串,得到: abcbcab和c,
第八次切出abcbcabc子字符串,得到: abcbcabc,
得到a1集合数组(且为数组吧)
元素为:a, ab, abc, ......2---再从b开始切::(字符串为abcbcabc )
第一次切出b子字符串,得到: b和cbcabc,
第二次切出bc子字符串,得到: bc和bcabc,
第三次切出bcb子字符串,得到: bcb和cabc,
第四次切出bcbc子字符串,得到: bcbc和abc,
第五次切出bcbca子字符串,得到: bcbca和bc,
第六次切出bcbcab子字符串,得到: bcbcab和c,
第七次切出bcbcabc子字符串,得到: bcbcabc
得到b2集合数组(且为数组吧)
元素为:b, bc, bcb ,......3---再从c开始切: (字符串为abcbcabc )
第一次切出c子字符串,得到: c和bcabc,
第二次切出cb子字符串,得到: cb和cabc,
第三次切出cbc子字符串,得到: cbc和abc,
第四次切出cbca子字符串,得到: cbca和bc,
第五次切出cbcab子字符串,得到: cbcab和c,
第六次切出cbcabc子字符串,得到: cbcabc
得到b3集合数组(且为数组吧)
元素为:c, cb, cbc ,......4----再从b开始切: (字符串为abcbcabc )
第一次切出b子字符串,得到: b和cabc,
第二次切出bc子字符串,得到: bc和abc,
第三次切出bca子字符串,得到: bca和bc,
第四次切出bcab子字符串,得到: bcab和c,
第五次切出bcabc子字符串,得到: bcabc
得到b4集合数组(且为数组吧)
元素为:b, bc, bca ,......5----再从c开始切: (字符串为abcbcabc )
第一次切出c子字符串,得到: c和abc,
第二次切出ca子字符串,得到: ca和bc,
第三次切出cab子字符串,得到: cab和c,
第四次切出cabc子字符串,得到: cabc
得到c5集合数组(且为数组吧)
元素为:c, ca, cab ,......6----再从a开始切: (字符串为abcbcabc )
第一次切出a子字符串,得到: a和bc,
第二次切出ab子字符串,得到: ab和c,
第三次切出abc子字符串,得到: abc,
得到a6集合数组(且为数组吧)
元素为:a, ab, abc 7----再从b开始切: (字符串为abcbcabc )
第一次切出b子字符串,得到: b和c,
第二次切出bc子字符串,得到: bc,
得到b7集合数组(且为数组吧)
元素为:b, bc8----再从c开始切: (字符串为abcbcabc )
第一次切出c子字符串,得到: c得到c8集合数组(且为数组吧)
元素为:c2,横向比:
将a的所有切点按切的顺序保存到称为a1集合数组中(且为数组吧)
将b的所有切点按切的顺序保存到称为b2集合数组中(且为数组吧)
依次类推到完。
得到如下8个集合:(字符串为abcbcabc )
行数/列数 1 2 3 4 5 6 7 8
1 a1: a, ab, abc, abcb, abcbc, abcbca , abcbcab, abcbcabc;
2 b2: b, bc, bcb , bcbc, bcbca, bcbcab, bcbcabc;
3 c3: c, cb, cbc , cbca, cbcab, cbcabc ;
4 b4: b, bc, bca , bcab, bcabc;
5 c5: c, ca, cab , cabc;
6 a6: a, ab, abc ;
7 b7: b, bc;
8 c8: c;
将a1集合,b2集合等全部集合横向比较:
即将列1比较,列2比较跳跃1行比较,列3跳跃2行比较,列3跳跃3行比较。到完;因为要求的是最多连续子字符串,所以要跳跃!
得到相同字符串记数最大值,即求出出现次数最多的子串。
比较方式:
正于前面所说,要求的是最多连续子字符串。其实就是优化笛卡尔积的原则,也是边界。所以我们要做的是将所有集合一对一比较,不是多对多或其他(更简单的理由:位数不同,无需比较)。
多位子字符串一对一比较时候,例如 ab属于a集合和b集合的bc比较,显然没有意义。需要跳跃比较(且这样说吧,呵呵)。跳跃是有规律的。很显然就不说了。
之所以纵切,是为了解决横比较带来的优化问题。