JAVA，
JAVA，
好的网站
http://www.importnew.com/cat/basic/page/2
JAVA TOOLS
http://www.importnew.com/12324.html
Java基础
http://www.importnew.com/12074.html
java book
http://www.importnew.com/4578.html
js:
http://04101334.iteye.com/blog/637695
package com.csdn.test;
import java.util.Arrays;
public class ReverseMutual {
public static void main(String[] args) {
ReverseMutual reverseMutual = new ReverseMutual();
// reverseMutual.getMaxReverseMutualLen("A");
// reverseMutual.getMaxReverseMutualLen("AN");
// reverseMutual.getMaxReverseMutualLen("AAOONN");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
// reverseMutual.getMaxReverseMutualLen("ABBBBBBN");
/*------------------------*/
reverseMutual.getMaxReverseMutualLen("DDGAGGAHHNND");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
// reverseMutual.getMaxReverseMutualLen("AAAOONNN");
}
private void getMaxReverseMutualLen(String inputStr) {
char[] chars = inputStr.toCharArray();
int original_max = getMaxReverseMutualLen(chars);
for (int i = 0, len = chars.length; i < len / 2; i++) {
char c = chars[i];
chars[i] = chars[len - i - 1];
chars[len - i - 1] = c;
}
int reverse_max = getMaxReverseMutualLen(chars);
System.out.println(inputStr + "------>>>" + "original_max: "
+ original_max + " " + "reverse_max: " + reverse_max);
}
private int getMaxReverseMutualLen(char[] inputChars) {
if (inputChars != null && inputChars.length >= 2) {
int inputCharsLen = inputChars.length;
int mid = inputCharsLen / 2;
return getMaxReverseMutualLen_fix_fix(mid, inputChars,
mutualReverse(Arrays.copyOfRange(inputChars, 0, mid)),
Arrays.copyOfRange(inputChars, mid, inputCharsLen));
} else {
return 0;
}
}
// 递归去判断判断固定的chars(长度固定-位置不固定)和剩余的chars
private int getMaxReverseMutualLen_fix_dynamic(int fixCharsLen,
char[] inputChars, char[] fixChars, char[] remianChars) {
int remianCharsLen = remianChars.length;
if (fixCharsLen == remianCharsLen) {
if (compareChars(fixChars, remianChars)) {
return fixCharsLen;
} else {
return 0;
}
}
// 剩余的字符串比固定的字符串长度只大1
else if (fixCharsLen + 1 == remianCharsLen) {
int result=0;
for (int i = 1; i < remianCharsLen; i++) {
if (compareChars_deleteOneChars(fixChars, remianChars, i)) {
return fixCharsLen;
} else {
result= getMaxReverseMutualLen_fix_fix(fixCharsLen, inputChars,
fixChars, Arrays.copyOfRange(remianChars, 1,
remianChars.length));
if(result==fixCharsLen){
return result;
}
}
}
}
return 0;
}
// 递归去判断判断固定的chars(长度及位置固定)和剩余的chars
private int getMaxReverseMutualLen_fix_fix(int fixCharsLen,
char[] inputChars, char[] fixChars, char[] remianChars) {
int remianCharsLen = remianChars.length;
// 剩余的字符串和固定的字符串长度相等,直接比较
if (fixCharsLen == remianCharsLen) {
if (compareChars(fixChars, remianChars)) {
return fixCharsLen;
} else {
return 0;
}
}
// 剩余的字符串比固定的字符串长度只大1
else if (fixCharsLen + 1 == remianCharsLen) {
for (int i = 1; i < remianCharsLen; i++) {
if (compareChars_deleteOneChars(fixChars, remianChars, i)) {
return fixCharsLen;
} else {
getMaxReverseMutualLen_fix_fix(fixCharsLen, inputChars,
fixChars, Arrays.copyOfRange(remianChars, 1,
remianChars.length));
}
}
} else {
// 剩余的字符串比固定的字符串长度大及等于2的情况
for (int i = 0; i < remianCharsLen - fixCharsLen;) {
if (i + fixCharsLen + 2 > remianCharsLen) {
return getMaxReverseMutualLen_fix_fix(fixCharsLen,
inputChars, mutualReverse(Arrays.copyOfRange(
inputChars, i, i + fixCharsLen)),
Arrays.copyOfRange(inputChars, fixCharsLen + i,
inputChars.length));
}
char[] dynamicChars = Arrays.copyOfRange(remianChars, i, i
+ fixCharsLen + 2);
// 开头第一个字符不相等就直接pass
if (fixChars[0] != dynamicChars[0]) {
i++;
continue;
}
// 针对n(n-1)种情况进行分析
for (int j = 1; j < fixCharsLen + 1; j++) {
for (int k = j + 1; k < fixCharsLen + 2; k++) {
if (compareChars_deleteTwoChars(fixChars, dynamicChars,
j, k)) {
return fixCharsLen;
}
}
}
i++;
if (getMaxReverseMutualLen_fix_fix(fixCharsLen, inputChars,
mutualReverse(Arrays.copyOfRange(inputChars, i, i
+ fixCharsLen)), Arrays.copyOfRange(inputChars,
i + fixCharsLen, inputChars.length)) == fixCharsLen) {
return fixCharsLen;
}
}
}
// 继续分析后续的固定字符串
// if(inputChars.length>=fixCharsLen*2+2){
// getMaxReverseMutualLen( fixCharsLen,Arrays.copyOfRange(inputChars, 1,
// inputChars.length),
// mutualReverse(Arrays.copyOfRange(inputChars, i, i
// + fixCharsLen)), remianChars);
// }
// 指定长度的字符串不满足要求就将长度减少1再继续判断知道找到为止
fixCharsLen--;
return getMaxReverseMutualLen_fix_fix(fixCharsLen, inputChars,
mutualReverse(Arrays.copyOfRange(inputChars, 0, fixCharsLen)),
Arrays.copyOfRange(inputChars, fixCharsLen, inputChars.length));
}
// 将输入的字符数组转换为对应的互补反向的字符串(just for 'A' to 'Z')
private char[] mutualReverse(char[] chars) {
int len = chars.length;
for (int i = 0; i < len; i++) {
chars[i] = chars[i] > 'M' ? (char) ((int) chars[i] - 13)
: (char) ((int) chars[i] + 13);
}
for (int i = 0; i < len / 2; i++) {
char c = chars[i];
chars[i] = chars[len - i - 1];
chars[len - i - 1] = c;
}
return chars;
}
// 判断两个相等长度字符数组是否相等
private boolean compareChars(char[] charsFirst, char[] charsSecond) {
int len = charsFirst.length;
for (int i = 0; i < len; i++) {
if (charsFirst[i] != charsSecond[i]) {
return false;
}
}
return true;
}
// 判断两个字符数组是否相等(其中一个是指定删除一个字符的字符串,删除后长度相等)
private boolean compareChars_deleteOneChars(char[] fixChars,
char[] dynamicChars, int romoveIndex) {
int index = 1;
for (int i = 1, len = dynamicChars.length; i < len; i++) {
if (i == romoveIndex) {
continue;
}
if (fixChars[index] != dynamicChars[i]) {
return false;
}
}
index++;
return true;
}
// 判断两个字符数组是否相等(其中一个是指定删除两个字符的字符串,删除后长度相等)
private boolean compareChars_deleteTwoChars(char[] fixChars,
char[] dynamicChars, int firstRomoveIndex, int secondRemoveIndex) {
int index = 1;
for (int i = 1, len = dynamicChars.length; i < len; i++) {
if (i == firstRomoveIndex || i == secondRemoveIndex) {
continue;
}
if (fixChars[index] != dynamicChars[i]) {
return false;
}
index++;
}
return true;
}
}
相关文章
- 暂无相关文章
用户点评