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;

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

1 struct node
2 {
3     char ha[1010];
4 } a[200];
结构体

 

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

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

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

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

  1 bool wordPattern(char* pattern, char* str)
  2 {
  3 
  4     ///printf("%d\n",'a');
  5     ///printf("[%c]",str[0]);
  6     memset(a,-1,sizeof(a));
  7     ///printf("111%d",a[1].ha[0]);
  8     int flag1=-1,flag2=-1;
  9     char tem[1010];
 10     int top=0;
 11     int len1=strlen(pattern),len2=strlen(str);
 12     int i,ans2=0;
 13     for(int l=0;l<len2;l++)
 14         if(str[l]==' ')
 15             ans2++;
 16     if(ans2==0)
 17     {
 18         if(len1>1)
 19             return false;
 20     }
 21     else
 22     {
 23         if(ans2+1!=len1)
 24             return false;
 25     }
 26     for(i=0; i<len1; i++)
 27     {
 28         memset(tem,0,sizeof(tem));
 29         if(flag1==-1&&flag2==-1)
 30         {
 31             ///printf("flag1=%d flag2=%d\n",flag1,flag2);
 32             top=0;
 33             int j;
 34             for(j=0; j<len2; j++)
 35             {
 36                 if(j==len2-1)
 37                 {
 38                     flag1=len2-1;
 39                 }
 40                 if(str[j]==' ')
 41                 {
 42                     ///printf("%d\n",j);
 43                     flag1=j;
 44                     break;
 45                 }
 46             }
 47             //printf("%d\n",flag1);
 48             for(j=0; j<flag1; j++)
 49                 tem[top++]=str[j];
 50             if(flag1==len2-1)
 51                 tem[top++]=str[flag1];
 52             strcpy(a[(int)pattern[i]].ha,tem);
 53 
 54             //printf("[%s]",a[(int)pattern[i]].ha);
 55         }
 56         else if(flag1!=-1&&flag2==-1)
 57         {
 58 
 59             ///printf("flag1=%d flag2=%d\n",flag1,flag2);
 60             memset(tem,0,sizeof(tem));
 61             top=0;
 62             for(int j=flag1+1; j<=len2; j++)
 63             {
 64                 if(j==len2-1)
 65                 {
 66                     flag2=len2-1;
 67                 }
 68                 if(str[j]==' ')
 69                 {
 70                     flag2=j;
 71                     break;
 72                 }
 73             }
 74             for(int j=flag1+1; j<flag2; j++)
 75                 tem[top++]=str[j];
 76 
 77             if(flag2==len2-1)
 78                 tem[top++]=str[flag2];
 79 
 80             if(pattern[i]==pattern[i-1])
 81             {
 82                 if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
 83                     return false;
 84             }
 85             ///printf("[[[%s",tem);
 86             for(int k=96; k<=122; k++)
 87             {
 88                 if(k==(int)pattern[i])
 89                     continue;
 90 
 91                 if(strcmp(a[k].ha,tem)==0)
 92                     return false;
 93 
 94             }
 95             strcpy(a[(int)pattern[i]].ha,tem);
 96 
 97 
 98         }
 99         else
100         {
101 
102             memset(tem,0,sizeof(tem));
103             if(flag1==len2-1||flag2==len2-1)
104                 return true;
105             if(flag1>flag2)
106             {
107                 ///printf("flag1=%d flag2=%d\n",flag1,flag2);
108                 top=0;
109                 for(int j=flag1+1; j<=len2; j++)
110                 {
111                     if(j==len2-1)
112                     {
113                         flag2=len2-1;
114                     }
115                     if(str[j]==' ')
116                     {
117                         flag2=j;
118                         break;
119                     }
120 
121                 }
122                 for(int j=flag1+1; j<flag2; j++)
123                     tem[top++]=str[j];
124 
125                 if(flag2==len2-1)
126                     tem[top++]=str[flag2];
127 
128                 if(a[(int)pattern[i]].ha[0]!=-1)
129                 {
130                     //printf("{{%s}}\n",a[(int)pattern[i]].ha);
131                     //printf("%s\n",tem);
132                     if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
133                         return false;
134                 }
135                 else
136                 {
137                     for(int k=97; k<=122; k++)
138                     {
139                         if(k==(int)pattern[i])
140                             continue;
141                         else
142                         {
143 
144                             if(strcmp(a[k].ha,tem)==0)
145                                 return false;
146                         }
147                     }
148                     strcpy(a[(int)pattern[i]].ha,tem);
149                 }
150 
151             }
152             else
153             {
154                 ///printf("{flag1=%d flag2=%d}\n",flag1,flag2);
155                 if(flag1==len2-1||flag2==len2-1)
156                     return true;
157                 top=0;
158                 for(int j=flag2+1; j<=len2; j++)
159                 {
160                     if(j==len2-1)
161                     {
162                         flag1=len2-1;
163                     }
164                     if(str[j]==' ')
165                     {
166                         flag1=j;
167                         break;
168                     }
169                 }
170                 for(int j=flag2+1; j<flag1; j++)
171                     tem[top++]=str[j];
172 
173                 if(flag1==len2-1)
174                     tem[top++]=str[flag1];
175 
176                 if(a[(int)pattern[i]].ha[0]!=-1)
177                 {
178                     ///printf("%s",a[(int)pattern[i]].ha);
179                     ///printf("{%s}\n",tem);
180                     if(strcmp(a[(int)pattern[i]].ha,tem)!=0)
181                         return false;
182                 }
183                 else
184                 {
185                     for(int k=97; k<=122; k++)
186                     {
187                         if((k==(int)pattern[i]))
188                             continue;
189                         else
190                         {
191                             if(strcmp(a[k].ha,tem)==0)
192                                 return false;
193                         }
194                     }
195                     strcpy(a[(int)pattern[i]].ha,tem);
196                 }
197 
198             }
199         }
200     }
201 
202     if(i!=len1)
203         return false;
204 
205     printf("111");
206     if(flag1>flag2)
207     {
208         if(flag1!=len2-1)
209             return false;
210     } else {
211         if(flag2!=len2-1)
212             return false;
213     }
214 
215     return true;
216 }
wordPattern

 

posted @ 2018-10-30 18:21  阿十三  阅读(223)  评论(0)  编辑  收藏  举报