UVA - 1597 Searching the Web

原创 2017年09月10日 16:59:34
/*
  法一借鉴自bolg:http://blog.csdn.net/code4101/article/details/39587211
  
  收获:
  
  1. typedef定义数组类型,格式应为 typedef int int_array[80]; 此后int_array可作为有80个元素的int数组的简写
  http://blog.csdn.net/huang_xw/article/details/8273655
  
  2. 几个好用的define宏定义,简化代码
  
	#define rep(i,b) for(int i=0; i<(b); i++)
	#define foreach(i,a) for(__typeof((a).begin()) i=a.begin(); i!=(a).end(); ++i)
		
	***注意:__typeof函数在英文前面,是2个_,不是一个_
		
	同时学到了_typeof关键字的使用
	http://blog.csdn.net/cx132123/article/details/6641735
		
  3. 逗号表达式的返回值
  概括就是:在C++中,逗号表达式有时候是一种很有用的工具:(A,B,C),则从左到右求值,最后C的(返回)值作为整个表达式的值
  http://blog.csdn.net/songzitea/article/details/52177294
  
  4. 还有就是,由于文章输入用的是getline,getline是能读取空串(整个串只有一个回车符)的,所以务必记得,输入n、m两个数字之后,都有getchar(),否则,轻则PE,重则WA
*/


#include <iostream>
#include <cstdio>
#include <string>
#include <map>
#include <cstring>
#include <cctype> //字母的判断和转换,用<cctype>里的 isalpha 和 tolower,可以极大简化代码 
#include <sstream>
using namespace std;

#define rep(i, n) for (int i = 0; i < (n); i++)
#define foreach(i, a) for (__typeof( (a).begin() )i = a.begin(); i != (a).end(); i++) 
//这个头文件对STL类的,都很实用,学习了 
#define FOR for(int j = limit[i]; j < limit[i + 1]; j++) //遍历同一篇文章的所有行数
const int maxn = 1500 + 5;
typedef bool Bit[maxn]; 


int n, m, lines; // n:文档数,m:请求数,lines:文章行数
int limit[105]; //limit[i]记录第i篇文章从哪一行开始
string doc[maxn]; //储存文章
map<string, Bit> Index; // Index 的 key位单词,Bit[i]为true,表示标记key对应的单词在第一行出现过 

//将读取的某行做处理,分割为一个个单词,以记录某个单词在哪一行出现过
void update(string s, int p)
{
	string word;
	foreach(it, s)
	{
		if (isalpha(*it)) *it = tolower(*it);
		else *it = ' '; 
	}
	stringstream ss(s);
	while (ss >> word) Index[word][p] = true;
 } 

int main()
{
	cin >> n;
	getchar();//注意要有一个getchar()吃掉多余的回车,否则后面的那些串,都会恰好错位一行,最终PE
	rep(i, n)
	{
		limit[i] = lines;
		while (getline(cin, doc[lines]) && doc[lines] != "**********")
		{
			update(doc[lines], lines);
			lines++;
		}
	}
	limit[n] = lines; // 之所以此处要对limit[n]做处理,是因为 rep(i, n) 的宏定义中,i最多能取到(n-1),但 对FOR的宏定义中,有 j < limit[i + 1]这句,i+1的最大可能值,其实是可以取到 n的,所以如果不提前初始化好 limit[n](应初始化为第n篇文章的最后一行的行数+1,如程序中那样初始化),则必定WA 
	 
	string s; //存储请求
	Bit mark; //记录哪些行应输出(为了处理每篇文档输出后,还需输出的10个'-')
	
	bool *A, *B;
	cin >> m;
	getchar(); //注意要有一个getchar()吃掉多余的回车,否则后面的那些串,都会恰好错位一行,最终WA 
	for (int ii = 0; ii < m; ii++ )
	{
		getline(cin, s);
		
		if (s[0] == 'N')
		{
			A = Index[s.substr(4)];
			rep(i, n)
			{
				bool flag = true;
				FOR if (A[j]) //FOR代表遍历当前文章的所有行,找是否出现指定关键字,若出现,则不输出该文章 
				{
					flag = false;
					break;
				}
				FOR mark[j] = flag; //如果flag仍为true,说明整篇文章都没有给定的关键字,按照题目要求,该文章的所有行都要输出;否则,该篇文章全部不输出 
			}
		}
		else if (s.find("AND") != string::npos)
		{
			int pos = s.find(" AND "); //分离出所要找的两个关键词
			A = Index[s.substr(0, pos)];
			B = Index[s.substr(pos + 5)];
			memset(mark, 0, sizeof(mark));
			
			bool hasA, hasB; //分别在同一文章中,两个关键词是否都出现,必须两者都为true时,该行才可被标记为可输出
			rep(i, n)
			{
				hasA = hasB = false; //默认没出现
				FOR if (A[j]) 
				{
					hasA = true; break; // 遍历doc[i]这篇文章的所有行数,确定这篇文章中有无关键词A,有只需有一个(故可以用 break),但没有需要所有行全没有,对B同理 
				}
				FOR if (B[j])
				{
					hasB = true; break;
				}
				
				if (!(hasA && hasB)) continue; //若要输出,首先这篇文章必须同时包含A和B
				FOR mark[j] = (A[j] || B[j]); //按照题意,输出是输出至少包含一个关键字的,所以对于文章中已经同时出现A、B的情况以后,对于这篇文章要输出哪些行,只要是有至少一个关键词的行,都满足输出条件 
			 } 	 
		}
		else if ( s.find("OR") != string::npos )
		{
			int pos = s.find(" OR ");
			A = Index[s.substr(0, pos)];
			B = Index[s.substr(pos + 4)];
			rep(i, lines) mark[i] = (A[i] || B[i]);
			
			//注意对OR的处理,就并不需要按照文章遍历这步了,因为最终输出的,也就是出现至少一个关键词的行,所以,可以直接标记这些行,从这个角度,OR比AND和NOT这两种情况,可谓简单许多 
		}
		else
		{
			memcpy(mark, Index[s], sizeof(mark));
		}
		
		bool nowOut = false, hasOut = false; //nowOut标记当前是否需要输出10个连续-(此后简称“分隔符”),如果上一篇文章的查询有结果,即hasOut为true,自然应该输出;但是也要注意,分隔符只输出一次(在下一篇文章待输出的查询结果之前输出),所以要用两个bool变量做好控制
		//nowOut表示当前是否需要输出分隔符
		//hasOut表示当前(/上篇)文章有无查询结果输出,无输出则有一次输出分隔符的机会,在输出下一篇有输出结果的文章,的查询结果前输出(如果接下来几篇都无查询结果,分隔符就一直不输出)
		//一旦输出分隔符后,nowOut自然也应置false
		
		//同时,这种设定下,可以发现的是,如果n篇文章全都没有查询结果,那么hasOut和nowOut都为false,而只要某篇文章中有本次查询需要的结果,则两者必定不会都为false,可用这点判断是否输出 "Sorry, I found nothing."
		
		rep(i, n)
		{
			if (hasOut) nowOut = true; 
			 hasOut = false; 
			FOR if (mark[j])
			{
				if (nowOut)
				{
					cout << "----------" << endl;
					nowOut = false;
				}
				cout << doc[j] << endl;
				hasOut = true; //表示这篇文章有输出结果
			}
		}
		if (!hasOut && !nowOut) cout << "Sorry, I found nothing." << endl;
		
        cout << "==========" << endl;
    }
	 
	return 0;
}

/*
  法二借鉴自:
  http://blog.csdn.net/XieNaoban/article/details/52628860
  和
  https://github.com/morris821028/UVa/blob/master/temp/1597%20-%20Searching%20the%20Web.cpp
  
  
  收获:
  1. 如果对map的value,将其引用赋值给value的同类型,会比赋value值(map[key])的耗时少。
  因为如果只是赋值,此后每次对value的操作,都需要从map里面重新查找。而如果赋引用,相当于是一劳永逸,只用查找一次,减少了STL的使用对程序速度的影响
  
  详细的说法(本来写在注释中,现在单独剪切到收获中)
  
			set<int> &t = word_line[com[0]];

			  按照blog: http://blog.csdn.net/XieNaoban/article/details/52628860
			  中的分析,此处的引用,可谓是这个方法的神来之笔,使得运行速度大大减少
			  
			  为什么能提高效率?
			  
			  我的猜测:
			  按照RLJ曾在《入门经典》P123提到的:虽然map每次插入、查找和删除时间,和元素个数的对数呈线性关系;虽然map每次插入、查找和删除时间,和元素个数的对数呈线性关系;
			  但是,在一些对时间要求非常高的题目中,STL是有性能方面的瓶颈
			  而用LRJ的这两句总结,来分析这题,如果t前面不用引用,那么每次调用t时,都要从map中找到对应的单词应对应的集合,虽然map的查找尚算高效的了,但是,该代码在后来多次用到了t,只有将t设置为引用,才可以真正减少每次查找的时间消耗
			  
			  实在巧妙!应该好好学习下这个小技巧,可在卡TLE的时候思索,怎么降低STL对速度的影响
  
  2. 有关set的详细总结:
  http://blog.csdn.net/howardemily/article/details/53573427
  
  3. 十分保险的清楚缓存的方式
  while (getchar() != '\n');
  这种情况下,不仅清除掉多余的空格,甚至如果空格之前有多余的空白字符,也一并清除掉,使得不影响下一次的有效输入
  
  4. 利用位运算的与和或,代替逻辑运算的与和或
  这点不详细解释了,注意观察代码中out的定义方式,和更改方式(就是有out的地方,都重点关注一下,就能发现是怎么用位运算代替逻辑运算的)
  
  但是要注意:我猜博主之所以要这样代替,是因为,有 |= 和 &= 运算符,但是,&&= 和 ||= 运算符是不存在的,所以是为了书写的简化了
  
  换成逻辑运算我试过了,也没问题,但是此时,就必须把 out放到有值中,一起进行逻辑与/逻辑或了
*/

#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <cctype>
#include <string>
#include <sstream>
#define foreach(i, a) for (__typeof( (a).begin() )i = a.begin(); i != (a).end(); i++) 
#define rep(i, n) for(int i = 0; i < (n); i++)
const int INF = 0x3f3f3f3f;
using namespace std;
map<string, set<int> > word_line; //表示特定单词,在哪些行数中出现过,行数存入一个集合,作为value键
vector<string> doc; 
int limit[105];
int n, m, line; //分别依次为:文章数、指令数、当前所输入的行的行序号 

void storeInfo(string s, int line)
{
	string word;
	foreach(i, s)
	{
		if (isalpha(*i)) *i = tolower(*i);
		else *i = ' ';
	}
	stringstream ss(s);
	while (ss >> word)
	word_line[word].insert(line);
}

vector<string> _command(string s)
{
	string word;
	vector<string> temp;
	foreach(i, s)
	{
		if (isalpha(*i)) *i = tolower(*i);
		else *i = ' ';
	}
	stringstream ss(s);
	while (ss >> word)
	temp.push_back(word);
	return temp;
}

int main()
{
	string str;
	line = 0;
	cin >> n;
	while (getchar() != '\n');
	
	rep(i, n)
	{
		limit[i] = line; //记录每篇文章的起始行
		while (getline(cin, str) && str != "**********")
		{
			doc.push_back(str);
			storeInfo(str, line);
			line++;
		}
	}
	limit[n] = line; //边界处理 
	
	cin >> m;
	while (getchar() != '\n');
	rep(i, m)
	{
		getline(cin, str);
		vector<string> com = _command(str);
		
		int hasOut = 0; //分隔两篇文章中的输出
		if (com.size() == 1) // [word]
		{
			set<int> &t = word_line[com[0]];
			set<int>::iterator it = t.begin();
			//注意,it是t的迭代器,也就是出现了该单词的迭代器,其对应的元素,都是含有该单词的行数的集合,所以可以直接输出对应行(doc[*it]),只要注意不同文章之间要有的分隔符即可
			
			rep(j, n)
			{
				//在确认单词对应的所在行数的集合不为空的情况下,迭代器不断自增,直到找到属于该篇文章的范围
				while (it != t.end() && *it < limit[j]) it++;
				
				
				//不为空且该关键词的确在这篇文章中出现过,才会有输出
				if (it != t.end() && *it < limit[j + 1])
				{
					if (hasOut) cout << "----------" << endl;
					hasOut = 1;
					while (it != t.end() && *it < limit[j + 1])
					{
						cout << doc[*it] << endl;
						it++;
					}
					
				}
			}
		 }
		 else if (com.size() == 2) // NOT [word]
		 {
		 	set<int> &t = word_line[com[1]];
		 	set<int>::iterator it = t.begin();
		 	rep(j, n)
		 	{
				//首先先定位到当前文章的范围(因为t中存储的是所有有该单词的行数,可是这些行分布在不同的文章中)
		 		while (it != t.end() && *it < limit[j]) it++;
		 		
				//如果it在所有文章中都没出现过,自然在当前遍历的文章中也没出现过,这种情况下,前一个循环中,迭代器it不会自增,所以要单独提出这种情况来考虑
				//而后一种,*it >= ...的情况,则说明这个单词在别的文章出现过,但是在这篇没有;所以我们在试图定位的时候,居然定位到了后面的文章中,说明这篇文章确实无该关键词,应该全部输出
		 		if (it == t.end() || *it >= limit[j + 1])
		 		{
		 			if (hasOut) cout << "----------" << endl;
					hasOut = 1;
					for (int k = limit[j]; k < limit[j + 1]; k++)
					cout << doc[k] << endl;
				}
		 		
			}
		 }
		 else if (com.size() == 3) // [word] AND / OR [word]
		 {
		 	set<int> &s1 = word_line[com[0]];
		 	set<int> &s2 = word_line[com[2]];
		 	set<int>::iterator it = s1.begin();
		 	set<int>::iterator jt = s2.begin();
		 	
		 	rep(j, n)
		 	{
		 		while (it != s1.end() && *it < limit[j]) it++;
		 		while (jt != s2.end() && *jt < limit[j]) jt++;
		 		
		 		int out;
		 		
		 		if (com[1] == "and") //AND要求这两个关键词,都在文章中出现过
		 		{
		 			out = 1;
		 			out &= ( it != s1.end() ) && ( *it < limit[j + 1]);
		 			out &= ( jt != s2.end() ) && ( *jt < limit[j + 1]);
				}
				else//OR要求这两个关键词,只要有一个出现过即可
				{
					out = 0;
					out |= ( it != s1.end() ) && ( *it < limit[j + 1]);
					out |= ( jt != s2.end() ) && ( *jt < limit[j + 1]);
				}
				if (!out) continue;//如果这篇文章查询结果无输出,则转而判断下一篇文章
				if (hasOut) cout << "----------" << endl;
				
				hasOut = 1;
				while (1)
				{
					int a = INF, b = INF;
					if (it != s1.end() && *it < limit[j + 1]) a = *it;
					if (jt != s2.end() && *jt < limit[j + 1]) b = *jt;
					
					if (a == b && a == INF) break;
					//此句不可漏掉,否则RE;它是为了判断,何时才能退出输出的循环;
					//如果前面的两个if,都没有给a或b改值,它们两的值都还是初始化为的INF,说明剩余的行,都不满足至少有一个关键词的输出要求
					
					if (a < b) it++;//如果第一个关键词出现的行数在前,不需改a,且将遍历第一个关键词所有出现行的迭代器,it,自增
					else if (a > b) jt++, a = b;//因为最终输出的是第a行,所以赋b给a
					else it++, jt++;//两者相等就不必改a了,不过两个迭代器都有必要变动
					
					cout << doc[a] << endl;
				}	
			}
		 }
		 if (!hasOut)
				cout << "Sorry, I found nothing." << endl;
				cout << "==========" << endl;
	}
	return 0;
}


版权声明:欢迎大家转载,转载请注明出处: ( http://blog.csdn.net/mofushaohua_ln )

相关文章推荐

UVa:1597 - Searching the Web

题目思路:首先需要构造出关键词的字典,提取关键字有一个小技巧:可以把字符串中所有非英文字母化为空格,然后用stringstream读取 void updatedic(string str,int...

[刷题]算法竞赛入门经典(第2版) 5-10/UVa1597 - Searching the Web

题意:不难理解,照搬题意的解法。代码:(Accepted,0.960s)//UVa1597 - Searching the Web #include #include #include #includ...

UVa 1597 - Searching the Web

这道题仍然是做了3个月,一直超时和WA,最后参考某大神的AC代码终于过了。巧妙的地方就是运用||和&&来进行搜索时的“和”和“或”操作,另外分析文章后的存储数据的数据结构也很重要,还有代码中很多重复的...

uva 1597 Searching the Web (wrong)

题目:Searching the Web 思路: 做了几天,还是没过,先把错误记录下: (1)每输入一个指令,在文章中查找一遍。(TLE) (2)每个单词都对应一些文章号和行号,先处理后直接查找...

Uva - 1597 - Searching the Web

早晨写了好久,最后终于AC了,有一定的实际问题意义。 AC代码: 注意提交的时候选C++11,如果选C++会CE。 #include #include #include #include ...

Uva1597 -Searching the Web

Uva1597 -Searching the Web 输入n篇文章和m个询问,格式如下: 1、A:搜索包含关键字A的文章,按顺序输出所有包含关键字的行A AND         2、B:搜索包含关键字...

UVa 1597 - Searching the Web(模拟)

模拟网页搜索,直接遍历查找会超时,需要使用映射或指针一类的简化查找。 直接用STL写的,原本准备超时之后再用指针重写,没想到2.595s过了,就懒得改了。

UVa1597 Searching the Web

先扯点废话

5-10 UVA 1597 Searching the Web在Web中搜索

大体题意: 输入许多文章,在输入许多命令,按照指定的格式输出文章或者对应的行。文章最多100个,最多总共1500行,命令最多50000个! 16751099 1597 Searching...

算法竞赛入门经典 第二版 习题5-10 在Web中搜索 Searching the Web uva1597

题目:https://vjudge.net/problem/UVA-1597思路:刚开始用string.find()暴力查找,然后果不其然的超时了,之后改用map过了。 用vector的数组data...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)