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;
 }
}