HDOJ-1181 字符串首尾相连问题[DFS（）+字符串排序strcmp（）||▲矩阵标记]

变形课

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)
Total Submission(s) : 4   Accepted Submission(s) : 1

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

呃......变形课上Harry碰到了一点小麻烦,因为他并不像Hermione那样能够记住所有的咒语而随意的将一个棒球变成刺猬什么的,但是他发现了变形咒语的一个统一规律:如果咒语是以a开头b结尾的一个单词,那么它的作用就恰好是使A物体变成B物体.
Harry已经将他所会的所有咒语都列成了一个表,他想让你帮忙计算一下他是否能完成老师的作业,将一个B(ball)变成一个M(Mouse),你知道,如果他自己不能完成的话,他就只好向Hermione请教,并且被迫听一大堆好好学习的道理.

Input

测试数据有多组。每组有多行，每行一个单词,仅包括小写字母,是Harry所会的所有咒语.数字0表示一组输入结束.

Output

如果Harry可以完成他的作业,就输出"Yes.",否则就输出"No."(不要忽略了句号)

Sample Input

so
soon
river
goes
them
got
moon
begin
big
0

Sample Output

Yes.

Hint

Hint
Harry 可以念这个咒语:"big-got-them".

Source

Gardon-DYGG Contest 1
 
 
code：（TLE）    我知道是自己剪枝没做好，也不知道如果事先不排序的话，是否一定会TLE，希望有人看到，给我指点一下啊！
  
 1 #include<iostream>
 2 using namespace std;
 3 
 4 char data[100][100];                         //数据
 5 int i;                                      //字符串个数
 6 int vst[100];                                //标记是否访问
 7 bool flag;                                  //是否已找到结果
 8 int count;                                 //记录已找到的单词数
 9 
10 void DFS(int tag)
11 {
12     int j;
13     if(count>=i)
14         return;
15     if(data[tag][strlen(data[tag])-1]=='m')                  //出现目标态
16     {
17         flag=true;
18         printf("Yes.\n");
19         return;
20     }
21     for(j=0;j<i;j++)
22     {
23         if(!vst[j]&&data[j][0]==data[tag][strlen(data[tag])-1])    //判断条件：1、未访问过；2、首尾相连
24         {
25             vst[j]=1;
26             count++;
27             DFS(j);
28             if(flag)
29                 return;
30             vst[j]=0;
31         }
32     }
33     return;
34 }
35 
36 int main()
37 {
38     int j;
39     int flag1;               //标记是否有以m结尾的字符串
40     int flag2;               //标记是否有以b开头的字符串
41     while(1)
42     {
43         i=0;
44         flag1=0;
45         flag2=0;
46         flag=false;
47         while(scanf("%s",data[i++]))
48         {
49             if(data[i-1][strlen(data[i-1])-1]=='m')
50                 flag1=1;
51             if(data[i-1][0]=='b')
52                 flag2=1;
53             if((data[i-1][0]-'0')==0)
54                 break;
55         }
56         if(flag1&&flag2)
57         {
58             for(j=0;j<i;j++)
59             {
60                 count=0;
61                 if(data[j][0]=='b')                     //找到以b开头的字符串为根
62                 {
63                     memset(vst,0,sizeof(vst));
64                     vst[j]=1;                           //标记
65                     DFS(j);
66                     if(flag)                            
67                         break;
68                 }
69             }
70         }
71         if(!flag||!flag1||!flag2)
72             printf("No.\n");
73     }
74     return 0;
75 }

 

 
 别人的代码1：
 
DFS（）+字符串排序
       
 1 #include <stdio.h> 
 2 #include <stdlib.h> 
 3 #include <string.h> 
 4 #define N 1000 
 5 #define M 30 
 6 char ch[N][M]; 
 7 int visited[N],n; 
 8   
 9 int cmp(const void *a, const void *b) 
10 { 
11     char *c = (char *) a; 
12     char *d = (char *) b; 
13     return strcmp(c,d); 
14 } 
15   
16 int DFS_Visit(int cur,char *word) 
17 { 
18     int i,flag=0,len=strlen(word); 
19     visited[cur]=1;//对已经选择的单词进行标记 
20     if(word[len-1]=='m') flag=1; 
21     else
22         for(i=0;i<n;i++) 
23         { 
24             if(!visited[i]&&word[len-1]==ch[i][0])//搜索前提 
25                 if(DFS_Visit(i,ch[i])) 
26                 { 
27                     flag=1; 
28                 } 
29         } 
30     visited[cur]=0;//标记还原，以便上一层的搜索可以继续选择该单词 
31     return flag; 
32 } 
33   
34 int DFS() 
35 { 
36     int i; 
37     memset(visited,0,sizeof(visited)); 
38     qsort(ch,n,sizeof(ch[0]),cmp);//按字典序排列 
39     for(i=0;i<n;i++)//递归外层枚举以b为首的字母 
40     { 
41         if(ch[i][0]>'b') break;//首字母比b大的都不用搜索 
42         if(ch[i][0]=='b') 
43             if(DFS_Visit(i,ch[i])) 
44                 return 1; 
45     } 
46     return 0; 
47 } 
48   
49 int main() 
50 { 
51     int i=0; 
52 //  freopen("变形课.txt","r",stdin); 
53     while(gets(ch[i])!=NULL) 
54     { 
55         if(ch[i][0]=='0') 
56         { 
57             n=i,i=-1; 
58             if(DFS()) printf("Yes.\n"); 
59             else printf("No.\n"); 
60         } 
61         i++; 
62     } 
63     return 0; 
64 }

 

 别人的代码2：（▲矩阵标记）                       

                      不错的思维方式！

                      虽然这代码过了测试数据，其实是不正确的

                      例如测试数据为：

                      另外说一句，杭电里的这道题测试数据是有缺陷的，如果你第一次输出的是Yes.，之后全部输出No.也能过了。

                    

                                         

 1 #include<iostream>
 2 using namespace std;
 3 int main()
 4 {
 5     int i,j,k,len;
 6     char s[100],mark[30][30];             //s存数据，mark标记
 7     while(gets(s))
 8     {
 9         memset(mark,0,sizeof(mark));
10         while(s[0]!='0')
11         {
12             len=strlen(s);
13             mark[s[0]-'a'][s[len-1]-'a']=1;
14             gets(s);
15         }
16         for(k=0;k<26;k++)
17             for(i=0;i<26;i++)
18             {
19                 if(i!=k&&mark[k][i]==1)
20                 {
21                     for(j=0;j<26;j++)
22                         if(mark[k][j]||mark[i][j])
23                             mark[k][j]=1;
24                 }
25             }
26         if(mark[1][12]==1)
27             puts("Yes.");
28         else
29             puts("No.");
30     }
31     return 0;
32 }

 别人的代码3：

      很标准的代码，我的目标！

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <cmath>
 4 #include <string>
 5 #include <algorithm>
 6 #include <iostream>
 7 using namespace std;
 8 const int N=110;
 9 
10 string str[N];
11 bool vis[N],flag;
12 int cnt;
13 
14 void dfs(char s)
15 {
16     if(s=='m')
17     {
18         flag=true; 
19         return ;
20     }
21     for(int i=0;i<cnt;i++)
22     {
23         if(str[i][0]==s&&!vis[i])
24         {
25             int len=str[i].length();
26             vis[i]=true;
27             dfs(str[i][len-1]);
28             vis[i]=false;
29         }
30     }
31 }
32 
33 int main(){
34     
35     // freopen("data.in","r",stdin);
36     // freopen("data.out","w",stdout);
37     
38     while(cin>>str[cnt])
39     { 
40         if(str[cnt]=="0")
41         {
42             memset(vis,false,sizeof(vis));
43             flag=false;
44             dfs('b');
45             if(flag) puts("Yes.");
46             else puts("No.");
47             cnt=0; 
48         } 
49         cnt++; 
50     }
51     return 0;
52 }

 

 
 
补充：
    

(一)strcmp函数  

         strcmp函数是比较两个字符串的大小,返回比较的结果。一般形式是：  

                 i=strcmp(字符串，字符串);

         其中，字符串１、字符串２均可为字符串常量或变量；i   是用于存放比较结果的整型变量。比较结果是这样规定的：  

        ①字符串1小于字符串2,strcmp函数返回一个负值;

        ②字符串1等于字符串2,strcmp函数返回零;

        ③字符串1大于字符串2,strcmp函数返回一个正值;那么,字符中的大小是如何比较的呢?来看一个例子。

         实际上,字符串的比较是比较字符串中各对字符的ASCII码。首先比较两个串的第一个字符，若不相等，则停止比较并得出大于或小于的结果；如果相等就接着 比较第二个字符然后第三个字符等等。如果两上字符串前面的字符一直相等,像"disk"和"disks"   那样,   前四个字符都一样,   然后比较第 五个字符,   前一个字符串"disk"只剩下结束符'/0',后一个字符串"disks"剩下's','/0'的ASCII码小于's'的ASCII 码,所以得出了结果。因此无论两个字符串是什么样，strcmp函数最多比较到其中一个字符串遇到结束符'/0'为止，就能得出结果。

注意:字符串是数组类型而非简单类型，不能用关系运算进行大小比较。  

         if("ABC">"DEF")   /*错误的字符串比较*/

         if(strcmp("ABC","DEF")   /*正确的字符串比较*/

（二）strcpy函数  

         strcpy函数用于实现两个字符串的拷贝。一般形式是：  

                 strcpy（字符中1,字符串2)

         其中,字符串1必须是字符串变量,而不能是字符串常量。strcpy函数把字符串2的内容完全复制到字符串1中,而不管字符串1中原先存放的是什么。复制后，字符串2保持不变。  

例:    

         注意,由于字符串是数组类型,所以两个字符串复制不通过赋值运算进行。  

         t=s;   /*错误的字符串复制*/

         strcpy(t,s);   /*正确的字符串复制*/

 

心得：

     //    写代码要简洁，高效
     //    先对字符串数组进行排序
     //    strcmp()
     //    当题目做不出来时就给自己的代码写备注

posted @ 2012-06-20 09:28  max_xbw  阅读(1450)  评论(0)  编辑  收藏  举报