C++博客-lzh-随笔分类-数据结构及算法问题

杭电1010（DFS，剪枝）

lzh525 — Sun, 03 Apr 2011 13:37:00 GMT

Tempter of the Bone Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 21915 Accepted Submission(s): 6011 Problem Description The doggie found a bone in an ancient maze, which fascinated him a lot. However, when he picked it up, the maze began to shake, and the doggie could feel the ground sinking. He realized that the bone was a trap, and he tried desperately to get out of this maze. The maze was a rectangle with sizes N by M. There was a door in the maze. At the beginning, the door was closed and it would open at the T-th second for a short period of time (less than 1 second). Therefore the doggie had to arrive at the door on exactly the T-th second. In every second, he could move one block to one of the upper, lower, left and right neighboring blocks. Once he entered a block, the ground of this block would start to sink and disappear in the next second. He could not stay at one block for more than one second, nor could he move into a visited block. Can the poor doggie survive? Please help him. Input The input consists of multiple test cases. The first line of each test case contains three integers N, M, and T (1 < N, M < 7; 0 < T < 50), which denote the sizes of the maze and the time at which the door will open, respectively. The next N lines give the maze layout, with each line containing M characters. A character is one of the following: 'X': a block of wall, which the doggie cannot enter; 'S': the start point of the doggie; 'D': the Door; or '.': an empty block. The input is terminated with three 0's. This test case is not to be processed. Output For each test case, print in one line "YES" if the doggie can survive, or "NO" otherwise. Sample Input 4 4 5 S.X. ..X. ..XD .... 3 4 5 S.X. ..X. ...D 0 0 0 Sample Output NO YES /*刚看到提示觉得就是一个普通的棋盘搜索的问题，因为以前做过所以马上开始敲代码，到后来发现连测试数据都过不了，再后来就是WA。后面记过调试才发现循环搜索遍历后没复原。后来终于自己的测试数据都过了，提交后才悲剧地发现TLE。看了很久之后觉得到网上找答案了，原来是一个剪枝没处理。铜鼓这个题又又发现了很多问题 1.基本的算法要熟悉弄通，例如此题就是一个典型的DFS，我很久前学过但没怎么用，没很好的掌握。开始做时完全按照自己的思路，虽然写出来了但效率不高 2.算法效率越见重要，最后还是一个数学问题，多总结 */ //下面是自己盲目写的算法，虽然册数数据过了但超时 /*#include #include using namespace std; #define N 8 char maze[N][N]; bool flag[N][N]; int direction[4][2]={0,1,1,0,0,-1,-1,0}; bool sign; int num; void init() { int i,j; for(i=0;i=s) { if(maze[x][y]=='D') { sign=true; return ; } else continue; } else { if(maze[x][y]=='D') continue; else { cout<>row>>column>>limit) { getchar(); // if(!(row|column|limit)) //全0则输入结束 // break; if(0==row&&0==column&&0==limit) return 0; init(); for(i=1;i<=row;i++) { for(j=1;j<=column;j++) { cin>>maze[i][j]; if(maze[i][j]=='S') { Ss=i; Se=j; } if(maze[i][j]!='X') { flag[i][j]=true; num++; } } getchar(); } times=0; num=0; sign=false; flag[Ss][Se]=false; if(num-1>=limit) //限制的时间小于等于所有的街区数时才有可能有解 search(Ss,Se,limit,times); if(sign) cout<<"YES\n"; else cout<<"NO\n"; } return 0; } */ //之后经过剪枝后的代码 AC #include #include using namespace std; #define N 8 int ex,ey; //出口位置 int secs; //出口开启时间 bool sign; //找到出口的标志 bool flag[N][N]; //是否遍历过的标记数组 char maze[N][N]; int direction[4][2]={0,1,1,0,0,-1,-1,0}; void init() { int i,j; for(i=0;i>row>>column>>secs) { getchar(); //吸收回车 if(!(row|column|secs)) //全0则输入结束 break; init(); nums=0; sign=false; for(i=1;i<=row;i++) { for(j=1;j<=column;j++) { cin>>maze[i][j]; if(maze[i][j]=='S') { x0=i; y0=j; } else if(maze[i][j]=='D') { ex=i; ey=j; flag[i][j]=true; } else if(maze[i][j]=='X') nums++; else flag[i][j]=true; } getchar(); //吸收回车 } if(row*column-nums-1>=secs) dfs(x0,y0,0); if(sign) cout<<"YES\n"; else cout<<"NO\n"; } return 0; }

lzh525 2011-04-03 21:37 发表评论

KMP算法（字符串模式匹配）

lzh525 — Fri, 12 Nov 2010 02:29:00 GMT

KMP算法是一种高效的模式匹配算法，复杂度可以达到O(m+n)，而普通模式匹配算法的复杂度为O(m*n)。

普通模式匹配算法

　　从主串的第一个字符（或者给定的第pos个字符）开始和子串的第一个字符开始比较，若相等，则继续比较后面的字符。若不相等，则从主串本次开始比较的字符的下一个字符开始，与子串的第一个字符进行比较（即主串需要回退到本次比较开始字符的下一字符，模式串回退到首字符，主串与子串都需要回退）。
　　匹配成功的标志：比较到子串的’\0’
　　匹配失败的标志：比较到主串的’\0’，且此时子串的比较位不等于’\0’。
　　算法复杂度：O(m*n)

KMP算法

KMP算法的改进思路
　　在普通匹配算法中子串与模式串都需要回溯，但这些回溯不是必要的。因为当某一位发生失配时，可以根据已匹配的结果进行判断。该算法问题可以理解为，当模式串中的第k位与主串的第i位比较时发生不匹配时，需要将模式串向右滑动到哪里继续与主串的第i位进行比较？避免了不必要的主串回溯，减少了模式串回溯的位数，从而使算法复杂度提升到O(m+n)。

KMP算法的实现思路
　　从主串的第一个字符（或者给定的第pos个字符）开始和子串的第一个字符开始比较，若相等，则继续比较后面的字符。若不相等，则将模式串右移至合适的位置，找出模式串中合适的第k位与主串中发生不等的位进行对齐比较。算法继续。
　　模式串与主串对齐继续比较的第k位必须满足其前k-1位与主串发生失配位置的前k-1位匹配，且该k-1位字串必须是最长的字串（即不存在k’>k，使模式串中的前k’-1位与主串发生失配位置的前k’-1位匹配，这是为了保证不漏过可以匹配的串）。
　　该算法中的主程序同普通的匹配算法类似，区别在于当发生不匹配时，主串指针不需要回退（不动），将模式串右移到合适的位置继续进行比较。当模式串移动到第一位（下标为0）仍然不等时，主串指针右移一位。该算法的关键是模式串next[]的取得。
　　匹配成功的标志：比较到子串的’\0’
　　匹配失败的标志：比较到主串的’\0’，且此时子串的比较位不等于’\0’。

next[]数组的获得
　　next[]数组记录了当模式串第j位发生失配时，模式串需要移动到第k位，使第k位与主串发生失配的位对齐继续比较（next[j]=k）。next[]数组使用递推实现，假设next[j]=k已经获得，则从next[j]开始推next[j+1]。具体算法如下。
　　假设next[j]=k（第j位及之前的next[]值已经求得，k　　而同时由于：p[j-k+1]p[j-k+2]…p[j-1]=s[i-k+1]s[i-k+2]…s[i-1]
　　所以：p[1]p[2]…p[k-1]= p[j-k+1]p[j-k+2]…p[j-1]

情况1：
　　若p[k]=p[j]，即p[next[j]]=p[j]，那么：p[1]p[2]…p[k-1]p[k]= p[j-k+1]p[j-k+2]…p[j-1]p[j]，则根据定义：next[j+1]=k+1=next[j]+1

情况2：
　　若p[k]!=p[j]，即p[1]p[2]…p[k-1]p[k]!= p[j-k+1]p[j-k+2]…p[j-1]p[j]，即p[k]与p[j]发生不等。把p[k]为模式串，即模式串第k位发生失配，根据KMP算法的基本思路，当模式串第k位发生失配时，模式串应移动到第next[k]=k’位与主串进行比较。此时：p[1]p[2]…p[k’-1]= p[j-k’+1]p[j-k’+2]…p[j-1]。然后再比较p[k’]与p[j]，若相等，同情况1：next[j+1]=k’+1= next[k]+1；若不相等，返回到情况2的头进行比较。（两种判断均可以归入情况1或者情况2，所以可以进行循环）

情况3：
　　若next[k]=-1，即发生失配元素的前一个元素与第一个元素a[0]仍然不等，该应使该失配元素直接与第一个元素比较，next[j+1]=0。（该情况可与第一种情况合并（因为next[0]=-1））

简单得说：
　　从next[j]=k开始比较，首先将k与自身对齐比较（找可以与j对齐比较的最长子串），如果相等，则p[k]=p[j]，满足情况1。若不相同，即模式串第k位发生失配，移动到k'=next[k]位继续进行比较。返回情况1或者2。如果next[k]=-1（仅第1位的next[0]的值为-1），说明j+1的前一位j与第一位比较仍然不等，那应该让第j+1位直接与第1位（下标为0）进行比较。
　　next[k+1]的计算依赖于next[k]，next[k+1]仅有一种方式获得，即第k+1字符的前面k个字符完全匹配（或者前一元素与第一个元素仍然不匹配）。而next[k]是已经计算的，即next[k]可以保证第k字符的前面k-1个字符（除了第k个字符）完全匹配，而且该字串是最长字串。因为只需比较第k个字符是否匹配。匹配成功即情况一，匹配失败则继续寻找next[next[k]]。
　　编程时，每次进行计算next[j+1]时，必须保证j与k呈对应关系，即每新一次计算前，next[j]=k（next[j+1]=k+1，因而也可以写成next[++j]=++k）。

KMP算法的再改进

　　当第k+1位发生失配时，根据原算法，可以找到一个子串，与之匹配。此时，next[j+1]=k+1
但若 T[j+1]= T[next[j+1]]=T[k+1]，则当T[j+1]发生失配时，程序会使回到第next[j+1](=k+1)位，与T[j+1]所对应的主串字符进行比较。但由于主串字符已经不等于T[j+1]，因而也必然不等于T[next[j+1]]，因而此次比较必然失败。
　　改进：当T[j+1]= T[next[j+1]]=T[k+1]时，next[j+1]= next[next[j+1]]=next[k+1]，从而避免不必要的重复比较。

附：
普通模式匹配算法代码：
int mystrstr(char* S, char* T, int pos)
{
   int i=pos; //设置主串的指针位置（初始位置为给定的开始位置）
   int j=0; //设置子串的指针位置（初始位置为子串的首元素）

   while (S[i]!='\0')
   {
   if (T[j]=='\0') {return (i-j+1);} //比较到子串的’\0’，匹配成功
   if (S[i]==T[j]) {
   i++;
   j++;
   //子串与主串在该位的匹配值相等，则继续比较下一字符
   } else { //若不相同
   i=i-j+1; //主串回退到本次比较开始字符的下一字符
   j=0; //模式串回退到首字符
   }
   }
   return 0; 比较到主串的’\0’，且此时子串的比较位不等于’\0’，匹配失败
}

KMP主程序代码：
int mystrstr(char* S, char* T, int pos, const int* next)
{
   int i=pos; //主串指针
   int j=0; //模式串指针

   while (S[i]!='\0') //当主串指针所指字符不为'\0'时,继续比较
   {

   if (j==-1) {i++;j++;}
   // 当头元素仍然不匹配时,j=-1,此时j指针清0指向模式串的首元素, i指针指下主串的下一元素
   if (T[j]=='\0') {return (i-j+1);}
   // 当模式串指针所指元素为'\0'时,匹配完成,返回位置
   if (S[i]==T[j]) {
   i++;
   j++;
   //当模式串指针与主串指针所指元素相同时,两指针都相加.比较下一元素
   } else {
   j=next[j];
   //若模式串指针与主串指针所指内容不同时,模式串指针回退指到next[j]位置(第j位发生失配)
   }
   }
   return 0;
}

生成next[]数组代码
//该程序用next[i]来推测next[i+1]
//每次比较开始时next[i]=k,每次比较开始前i与k成对应关系
void GetNext (char* T,int* next)
{
   int j=0;
   int k=-1; //k为当第j位发生失配时,需要移动到的下一次进行比较的位(第k位)
   next[0]=-1;
   //给定初始值,当比较到第一个元素(下标为0)仍然不等时,k的值为-1

   while (j   {
   if (k==-1||T[k]==T[j])
   {
   //next[j]=k的定义为: t[0]...t[k-1]=t[j-k+1]...t[j-1]
   //当T[k]=T[j]时,即T[next[j]]=T[j]时,T[1]...T[k]=T[j-k+1]...T[j],此时next[j+1]=next[j]+1=k+1,即可以求出next[j+1]
   //当k=1时,即j+1的前一个元素与模式串的首元素相比,仍然不同,则应该让第j+1个元素直接与首元素进行比较
   next[j+1]=k+1;
   j++;
   k++; //k=next[j+1]=k+1,不能写k=next[j+1],因为上面一句j已经变化过了
   //next[j+1]=next[j]+1=k+1,即j+1与k+1是成对出现的
   //下次比较开始前,j与k必须成对应关系出现, 满足这个式子：next[j+1]=k+1
   } else {
   k=next[k];
   //如果不等,可以理解为模式串的第k(next[j])位发生不匹配
   //则寻找到第next[k]位(保证k之前的元素匹配)继续进行比较
   }
   }
}

生成KMP改进算法的next[]数组代码
void GetNext (char* T,int* next)
{
   int j=0;
   int k=-1;

   next[0]=-1;
   // next[j]=k

   while (j   {
   if (k==-1||T[k]==T[j])
   {
   next[j+1]=k+1;

   if (T[j+1]==T[next[j+1]]) {
   next[j+1]=next[next[j+1]];
   }
   //就多了这段，当T[j+1]与T[next[j+1]]相等时，使next[j+1]=next[next[j+1]]
   j++;
   k++;
   } else {
   k=next[k];
   }
   }
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ultrasurf/archive/2007/11/08/1873589.aspx

lzh525 2010-11-12 10:29 发表评论

我总结的常见排序方法（c语言实现）

lzh525 — Thu, 26 Aug 2010 12:43:00 GMT

1#include<iostream>
2#include<malloc.h>
3using namespace std;
4
5bool cmp(int &a,int &b)//sort函数的比较函数，若将"<"改为">"则为降序排列
6{

7  return a<b;

8}
9
10int comp(const void*a,const void*b)//C语言qsort的升序排序函数，将return语句的a,b互换则为降序排序
11{

12  return *(int*)a-*(int*)b;

13}
14
15void sel_sort(int *s,int n)//选择排序，分为有序，无序两部分。每次迭代中选择无序部分的最小元素，并移动到有序部分的尾部
16{
17    int i,j;
18    int min;
19    for(i=0;i<n;i++)
20    {
21        min=i;
22        for(j=i+1;j<n;j++)
23            if(s[j]<s[min])
24                min=j;
25            swap(s[i],s[min]);
26    }
27}
28
29void insert_sort(int *s,int n)//插入排序，分为有序，无序两部分。每次迭代中无序部分的下一个元素被插入到有序部分的何时位置。
30{
31    int i,j;
32    for(i=1;i<n;i++)
33    {
34        j=i;
35        while((j>0)&&(s[j]<s[j-1]))
36        {
37            swap(s[j],s[j-1]);
38            j--;
39        }
40    }
41}
42
43void quick_sort(int *s,int left,int right)//快速排序
44{
45    int r=right,l=left,p=s[right];
46    while(l<r)
47    {
48        swap(s[l],s[r]);
49        while(l<r&&s[r]>p)
50            r--;
51        while(l<r&&s[l]<=p)
52            l++;
53    }
54    swap(s[left],s[r]);
55    if(left<r-1)
56        quick_sort(s,left,r-1);
57    if(right>r+1)
58        quick_sort(s,r+1,right);
59}
60
61int main()
62{
63    int i,n;
64    int *a;
65    while(cin>>n)
66    {
67        //a=(int *)malloc(n*sizeof(int));
68        a=new int[n];
69        for(i=0;i<n;i++)
70            cin>>a[i];
71        sel_sort(a,n);
72        //insert_sort(a,n);
73        //quick_sort(a,0,n-1);
74                //sort(a,a+n,cmp);//c++排序库函数
75                //qsort(a,n,sizeof(int),comp);//c排序库函数
76        for(i=0;i<n;i++)
77        {
78            cout<<a[i];
79            if(i!=n-1)
80                cout<<",";
81            if(i==n-1)
82                cout<<endl;
83        }
84    }
85    //free(a);
86    delete(a);
87    return 0;
88}

lzh525 2010-08-26 20:43 发表评论

八皇后问题（回溯法）

lzh525 — Sun, 22 Aug 2010 13:19:00 GMT

摘要: 1 /* 2 3 N皇后问题算法思想 4 5 由于这是一个平面上棋子布局处理问题，因此，我们可以将问题看成是一个二维数组问题。给八个皇后分别编号为1,2，…,8，其中第i个皇后放置在第i行上，并这就解决了不同皇后分别摆放在不同列的问题，这样又可以把问题简化为一个一维数组的问题，假设用一维数组arr来存放皇后所放置的列，对于第i个皇后，假设它存放在ar... 阅读全文

lzh525 2010-08-22 21:19 发表评论

回溯法之应用---生成全排列，子集

lzh525 — Sun, 22 Aug 2010 02:58:00 GMT

摘要: 全排列的生成1 #include 2 using namespace std; 3 4 const int MAX=100; 5 int a[MAX]; 6 bool finished=false;//是否找到了所要全部求的解 7 8 void process(int *a,int n) 9 { 10 int i,fir... 阅读全文

lzh525 2010-08-22 10:58 发表评论