[算法 笔记]字符串移位包含问题

　　问题出自《编程之美》3.1 

/* 2013.6.25
 * 问题：给定两个字符串s1和s2，要求判定给定字符串s2是否
 * 能够通过字符串s1循环移位得到的字符串包含。
 * 例如：
 * 1. s1 = AABCD，s2 = CDAA，则返回true；
 * 2. s1 = ABCD，s2 = ACBD，则返回false
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

enum { true = 1, false = 0 };

/* 2013.6.25
 * 方式1：用s2[0]将字符串s1分为两个部分。
 * 第一部分：strcmp(s2, s1 + j, strlen(s1)-j) ,其中，j是s2[0] == s1[j]
 * 第二部分：strcmp(s2 + strlen(s1) - j, s1, strlen(s2) - strlen(s1) - j).
 * 时间复杂度：O( strlen(s1) * strlen(s2) ), 空间复杂度：O(1)
 */
int CheckRotStr1( const char *s1, const char *s2 )
{
    int start = 0;
    int nlen1, nlen2, tmpLen;

    if ( s1 == NULL || s1[0] == ''
        || s2 == NULL || s2[0] == '' )
    {
        printf( "Error for arguments!
" );
        return -1;
    }

    // 查找s2[0]在s1中的位置
    nlen1 = strlen( s1 );
    nlen2 = strlen( s2 );
    while ( start < nlen1 )
    {
        if ( s2[0] == s1[start] )
            break;

        ++start;
    }

    if ( start == nlen1 )
        return false;

    tmpLen = nlen1 - start;
    if ( strncmp( s2, s1 + start, tmpLen ) == 0 )
    {
        if ( tmpLen == nlen2 )
            return true;

        start = tmpLen;
        tmpLen = nlen2 - tmpLen;
        if ( strncmp( s2 + start, s1, tmpLen ) == 0 )
            return true;
    }

    return false;
}

/* 2013.6.25
 * 方式2：拷贝一份s1填充到s1后面，然后查找s2是否为s1的子串。
 * 时间复杂度：O(strlen(s2)*strlen(s1)), 空间复杂度：O(2*strlen(s1))
 */
int CheckRotStr2( const char *s1, const char *s2 )
{
    char *newS1 = NULL;
    int nlen1, nlen2, start = 0;

    if ( s1 == NULL || s1[0] == ''
        || s2 == NULL || s2[0] == '' )
    {
        printf( "Error for arguments!
" );
        return -1;
    }

    nlen1 = strlen( s1 );
    nlen2 = strlen( s2 );
    newS1 = (char *) malloc( nlen1 * 2 * sizeof( char ) + 1 );
    if ( newS1 == NULL )
    {
        printf( "Error for malloc!
" );
        return -1;
    }

    // 拷贝字符串s1
    strncpy( newS1, s1, nlen1 );
    strncpy( newS1 + nlen1, s1, nlen1 );
    nlen1 <<= 1;
    newS1[nlen1] = '';

    // 查找s2[0]在newS1中的位置
    while ( start < nlen1 )
    {
        if ( s2[0] == newS1[start] )
            break;

        ++start;
    }

    if ( start == nlen1 )
        return false;

    if ( strncmp( s2, newS1 + start, nlen2 ) == 0 )
    {
        free( newS1 );
        return true;
    }

    free( newS1 );
    return false;
}

/* 2013.6.25
 * 方式3：思路和方式2一样，但是利用摩计算来省略拷贝问题
 * 时间复杂度：O(strlen(s2)+strlen(s1)), 空间复杂度：O(1)
 */
int CheckRotStr3( const char* s1, const char *s2 )
{
    int nlen1, nlen2, start = 0;
    int end, i = 0;

    if ( s1 == NULL || s1[0] == ''
        || s2 == NULL || s2[0] == '' )
    {
        printf( "Error for arguments!
" );
        return -1;
    }

    nlen1 = strlen( s1 );
    nlen2 = strlen( s2 );

    // 查找s2[0]在newS1中的位置
    while ( start < nlen1 )
    {
        if ( s2[0] == s1[start] )
            break;

        ++start;
    }

    if ( start == nlen1 )
        return false;

    end = start + nlen1;
    // 需要注意，如果nlen2超过nlen1的长度，则返回false。
    while ( start < end && i < nlen2 )
    {
        int tmp = start % nlen1; // 利用摩计算消除了拷贝的需求

        if ( s2[i] != s1[tmp] )
            break;

        ++start;
        ++i;
    }

    if ( i == nlen2 )
        return true;

    return false;
}

/* 2013.6.25
 * 以上三个函数在简单模式下成立。但是还是存在错误。
 */

/* 2013.6.25
 * 本次采用的是方式2，然后使用KMP来进行子串匹配。
 * KMP算法来自博客 算法之道
 * 网址：http://blog.csdn.net/v_july_v/article/details/7041827#comments
 */
int CheckRotStrOpt( const char *s1, const char *s2)
{
    int nlen1, nlen2;
    int *overlay_value = NULL;
    char* newS1 = NULL;
    int index = 0;
    int i, j, ret = false;

    if ( s1 == NULL || s1[0] == ''
        || s2 == NULL || s2[0] == '' )
    {
        printf( "Error for arguments.
" );
        return -1;
    }

    nlen1 = strlen( s1 );
    nlen2 = strlen( s2 );

    newS1 = (char *) malloc( nlen1 * 2 * sizeof( char ) + 1 );
    if ( newS1 == NULL )
    {
        printf( "Error for malloc!
" );
        return -1;
    }

    // 拷贝字符串s1
    strncpy( newS1, s1, nlen1 );
    strncpy( newS1 + nlen1, s1, nlen1 );
    nlen1 <<= 1;
    newS1[nlen1] = '';

    overlay_value = (int *) malloc( nlen2 * sizeof(int) );
    if ( overlay_value == NULL )
    {
        printf( "Error for malloc.
" );
        free( newS1 );
        return -1;
    }
    overlay_value[0] = -1;

    // nextArray
    for ( i = 1; i < nlen2; ++i )
    {
        index = overlay_value[i - 1];
        while ( index >= 0 && s2[index + 1] != s2[index] )
        {
            index = overlay_value[index];
        }

        if ( s2[index + 1] == s2[index] )
            overlay_value[i] = index + 1;
        else
            overlay_value[i] = -1;
    }

    i = 0, j = 0;
    while ( i < nlen2 && j < nlen1 )
    {
        if ( newS1[j] == s2[i] )
        {
            ++i;
            ++j;
        }
        else if ( i == 0 )
        {
            ++j;
        }
        else
        {
            i = overlay_value[i - 1] + 1;
        }
    }

    if ( i == nlen2 )
        ret = true;

    free( newS1 );
    free( overlay_value );

    return ret;
}

int main()
{
    char* str10 = "AABCDA";
    char* str11 = "ABCD";
    char* str20 = "CDAA";
    char* str21 = "ACBD";
    int ret = 0;

    ret = CheckRotStrOpt( str10, str20 );
    printf( "The result is %d.
", ret );

    ret = CheckRotStrOpt( str11, str21 );
    printf( "The result is %d.
", ret );

    return 0;
}