字符串

变形词：对于两个字符串A和B,如果A和B中出现的字符种类相同且出现的每种字符次数相同，则A和B为变形词，判断两个字符串A,B 是否为变形词？

Class Transform{
public :
    bool chkTransform(String A,int lena,string B,int lenb){
        if(lena!=lenb)
            return false;
        int hashTable1[256]={0},hashTable2={0},i;
        for(i=0;i<lena;i++){
            hashTable1[A[i]]++;
            hashTable[B[i]]++;
            }
        i=0;
        while((i<256) && hashTable[i]==HashTable2[i])
        i++;
        if(i>=256)
            return true;
        else
            return false;
        }
};

旋转词：对于一个字符串A，将A的前面任意一部分挪到后面形成的字符串称为A的旋转词。对于两个字符串A,B，请判断A和B 是否互为旋转词。

Class Rotation{
public:
    bool chkRotation(String A,int lena,String B,int lenb){
        if(lena != lenb) return false;
        String C = A + A ;
        for(int i=0;i<=lena;i++){
            String D = C.substr(i,lena);
            if(D==B)
                return true;
            }
        return false;
}

逆序词：对于一个字符串,只在字符串的单词间做逆序调整，给定一个原字符串和他的长度，请返回逆序后的字符串。

Class Reverse{
public :
    String reverseSentence(String A,int n){
        reverseWord(A,0,n-1);
        int i=0;j=0;
        while(i<n){
            while(i<n && A[i]==' ')
                i++;
            if(i>=n)
                return A;
            j=i;
            while(i<n && A[i]!=' ')
                i++;
            if(i>=n){
                reverse(A,j,n-1);
                return A;
                }
            revereWord(A,j,i-1);
        }
        return A;
    }

    void reverseWord(String &A,int low,int high){
        if(low>=high) return ;
        char temp;
        while(low<high){
            temp=A[low];
            A[low]=A[high];
            A[high]=temp;
            high--;
            low++;
        }
    }
};

移位词：对于一个字符串，将字符串的长度为len 的前缀平移到字符串的最后。

Class Translation{
public:
    String StringTranslation(String A,int n,int len){
        if(len>n) exit(-1);
        reverseWord(A,0,len-1);
        reverseWord(A,len,n-1);
        reverseWord(A,0,n-1);
        return A;
    }
    void reverseWord(String &A,int low,int high){
        if(low>=high) return;
        char temp;
        while(low<high){
            temp = A[low];
            A[low]=A[high];
            A[high]=temp;
            low++;
            high--;
        }
    }
}

无重复词：给定一个字符串A以及他的长度n，请返回以最长无重复字符字串长度，保证A中所有字符为小写。

其实另一种理解：以当前字符起，向前搜索遇到不重复字符数量（最长序列肯定以某一个位子为终点），然后选取整个数列中最大的值即可

思路如下：
如果一个字符出现在前面的序列中
1. 情况1：前面序列中字符与该字符相同的位置距离小于前一刻的无重复字符长度，说明前面字符贡献了重复长度，这时候以该位置作为起点的最长不重复字符为 两个相等字符距离和
2. 情况2：前面序列中字符与该字符相同的位置距离大于前一刻的无重复字符长度，直接=1

如果一个字符没有出现在前面序列中，直接＋1

Class DistinctSubString{
public :
    int longstSubString(String A,int n){
        map<char,int> map_table;
        int pre = 0;
        int *dp = new int[n]();
        for(int i=0;i<n;i++){
            if(map_table.count(A[i]){
                if(map_table[A[i]]>=(i-pre))
                    dp[i] = i-map_table[A[i]];
                else
                    dp[i] = pre+1;
            }
            else
                dp[i]=pre+1;
            pre=dp[i];
            map_table[A[i]]=i;
        }
        //以上计算过程得到以每个位置字符结尾对应的最长无重复字串，现在得到其中最长的即可。
        int res=0;
        for(int i=1;i<n;i++)
            if(dp[i]>res)
                res=dp[i];
        delete []dp;
        dp=NULL;
        return res;
    }
};