LeetCode 290 单词模式

给定一种 pattern(模式) 和一个字符串 str ，判断 str 是否遵循相同的模式。

这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应模式。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。    

提供两个思路吧

第一个思路最简单就是用字符串哈希，用pattern的每一个位置的字幕。作为哈希表的key，然后将str的单词作为value打进去哈希表

这个思路最简单了

第二个思路：我直接就是上去模拟，首先先把pattern的长度和str的空格数+1做一个比较，如果不想当就直接return false;

用一个结构体记录一对一的结果：

struct node
{
    char ha[1010];
} a[200];

然后在把遍历一遍patter，因为题目只要求小写字母，所以每个a[i]对对应一个字母，把他对于的单词拷贝到ha

每次拷贝前先跑一遍是否出现重复，如果出现重复就return false;

最后再看一遍i,j是否跑到了len1,len2-1

大体思路就是这样子，具体看我代码

bool wordPattern(char* pattern, char* str)
{

    ///printf("%d
",'a');
    ///printf("[%c]",str[0]);
    memset(a,-1,sizeof(a));
    ///printf("111%d",a[1].ha[0]);
    int flag1=-1,flag2=-1;
    char tem[1010];
    int top=0;
    int len1=strlen(pattern),len2=strlen(str);
    int i,ans2=0;
    for(int l=0;l<len2;l++)
        if(str[l]==' ')
            ans2++;
    if(ans2==0)
    {
        if(len1>1)
            return false;
    }
    else
    {
        if(ans2+1!=len1)
            return false;
    }
    for(i=0; i<len1; i++)
    {
        memset(tem,0,sizeof(tem));
        if(flag1==-1&&flag2==-1)
        {
            ///printf("flag1=%d flag2=%d
",flag1,flag2);
            top=0;
            int j;
            for(j=0; j<len2; j++)
            {
                if(j==len2-1)
                {
                    flag1=len2-1;
                }
                if(str[j]==' ')
                {
                    ///printf("%d
",j);
                    flag1=j;
                    break;
                }
            }
            //printf("%d
",flag1);
            for(j=0; j<flag1; j++)
                tem[top++]=str[j];
            if(flag1==len2-1)
                tem[top++]=str[flag1];
            strcpy(a[(int)pattern[i]].ha,tem);

            //printf("[%s]",a[(int)pattern[i]].ha);
        }
        else if(flag1!=-1&&flag2==-1)
        {

            ///printf("flag1=%d flag2=%d
",flag1,flag2);
            memset(tem,0,sizeof(tem));
            top=0;
            for(int j=flag1+1; j<=len2; j++)
            {
                if(j==len2-1)
                {
                    flag2=len2-1;
                }
                if(str[j]==' ')
                {
                    flag2=j;
                    break;
                }
            }
            for(int j=flag1+1; j<flag2; j++)
                tem[top++]=str[j];

            if(flag2==len2-1)
                tem[top++]=str[flag2];

            if(pattern[i]==pattern[i-1])
            {
                if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
                    return false;
            }
            ///printf("[[[%s",tem);
            for(int k=96; k<=122; k++)
            {
                if(k==(int)pattern[i])
                    continue;

                if(strcmp(a[k].ha,tem)==0)
                    return false;

            }
            strcpy(a[(int)pattern[i]].ha,tem);


        }
        else
        {

            memset(tem,0,sizeof(tem));
            if(flag1==len2-1||flag2==len2-1)
                return true;
            if(flag1>flag2)
            {
                ///printf("flag1=%d flag2=%d
",flag1,flag2);
                top=0;
                for(int j=flag1+1; j<=len2; j++)
                {
                    if(j==len2-1)
                    {
                        flag2=len2-1;
                    }
                    if(str[j]==' ')
                    {
                        flag2=j;
                        break;
                    }

                }
                for(int j=flag1+1; j<flag2; j++)
                    tem[top++]=str[j];

                if(flag2==len2-1)
                    tem[top++]=str[flag2];

                if(a[(int)pattern[i]].ha[0]!=-1)
                {
                    //printf("{{%s}}
",a[(int)pattern[i]].ha);
                    //printf("%s
",tem);
                    if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
                        return false;
                }
                else
                {
                    for(int k=97; k<=122; k++)
                    {
                        if(k==(int)pattern[i])
                            continue;
                        else
                        {

                            if(strcmp(a[k].ha,tem)==0)
                                return false;
                        }
                    }
                    strcpy(a[(int)pattern[i]].ha,tem);
                }

            }
            else
            {
                ///printf("{flag1=%d flag2=%d}
",flag1,flag2);
                if(flag1==len2-1||flag2==len2-1)
                    return true;
                top=0;
                for(int j=flag2+1; j<=len2; j++)
                {
                    if(j==len2-1)
                    {
                        flag1=len2-1;
                    }
                    if(str[j]==' ')
                    {
                        flag1=j;
                        break;
                    }
                }
                for(int j=flag2+1; j<flag1; j++)
                    tem[top++]=str[j];

                if(flag1==len2-1)
                    tem[top++]=str[flag1];

                if(a[(int)pattern[i]].ha[0]!=-1)
                {
                    ///printf("%s",a[(int)pattern[i]].ha);
                    ///printf("{%s}
",tem);
                    if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
                        return false;
                }
                else
                {
                    for(int k=97; k<=122; k++)
                    {
                        if((k==(int)pattern[i]))
                            continue;
                        else
                        {
                            if(strcmp(a[k].ha,tem)==0)
                                return false;
                        }
                    }
                    strcpy(a[(int)pattern[i]].ha,tem);
                }

            }
        }
    }

    if(i!=len1)
        return false;

    printf("111");
    if(flag1>flag2)
    {
        if(flag1!=len2-1)
            return false;
    } else {
        if(flag2!=len2-1)
            return false;
    }

    return true;
}