HDU2532 && BNU6657：Engine(模拟)

Problem Description

谷歌、百度等搜索引擎已经成为了互连网中不可或缺的一部分。在本题中，你的任务也是设计一个搜索论文的搜索引擎，当然，本题的要求比起实际的需求要少了许多。
本题的输入将首先给出一系列的论文，对于每篇论文首先给出标题，然后给出它被引用的次数。然后会有一系列的搜索询问，询问标题中包含特定关键词的论文有哪些。
每一个询问可能包含多个关键词，你需要找出标题包含所有关键词的论文。
“包含”必须是标题中有一个词正好是给定的关键词，不区分大小写。
对每个询问，都按被引用的次数从多到少输出满足条件的论文的标题。如果有被引用的次数相同的论文，则按照论文在输入中的顺序排列，先给出的论文排在前面。

 

Input

输入包含多组数据。
每组数据首先有一行包含一个整数N(1<=N<=1000)，表示论文的数目，N=0表示输入结束。每组论文的信息第一行是论文的标题，由字母（大小写均可）和空格组成，不超过10个词，每个词不超过20个字符，标题总共不超过250个字符。第二行是一个整数K(0<=K<=108)，表示它被引用的次数。在论文信息结束以后，有一行包含一个整数M(1<=M<=100)，表示询问的数目。接下来有M行，每行是一个询问，由L(1<=L<=10)个空格分开的词构成，每个词不超过20个字符。

 

Output

对每个询问，按照题目给定的顺序输出满足条件的论文的标题；如果没有满足条件的论文，就不输出。在每组询问的输出之后输出一行”***”，在每组数据的输出之后输出一行”---”。

 

Sample Input

   
   
   
   

    
    
    
    6
Finding the Shortest Path
120
Finding the k Shortest Path
80
Find Augmenting Path in General Graph
80
Matching in Bipartite Graph
200
Finding kth Shortest Path
50
Graph Theory and its Applications
40
6
shortest path
k shortest path
graph
path
find
application
0
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    Finding the Shortest Path
Finding the k Shortest Path
Finding kth Shortest Path
***
Finding the k Shortest Path
***
Matching in Bipartite Graph
Find Augmenting Path in General Graph
Graph Theory and its Applications
***
Finding the Shortest Path
Finding the k Shortest Path 
Find Augmenting Path in General Graph
Finding kth Shortest Path
***
Find Augmenting Path in General Graph
***
***
---
   
   
   
   
   
   
   
   

    
    
    
     
   
   
   
   
   
   
   
   

    
    
    
     
   
   
   
   
   
   
   
   

    
    
    
    简单模拟题，要求在原文中找到有关键字存在的所有句子，这些句子首先按照c查询次数排序，查询次数相等则按出现顺序排序
   
   
   
   
   
   
   
   

    
    
    
     
   
   
   
   
   
   
   
   

    
    
    
    
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

struct node
{
    char name[300];
    int cnt;
    int id;
    int len;
} s[1005];

char ss[300];

struct kode
{
    char name[30];
    int len;
} word[15];//存放查询的关键字内的所有单词

struct qode
{
    char name[30];
    int len;
} word2[15];//存放每一句里的单词

int cmp(node x,node y)
{
    if(x.cnt==y.cnt)
        return x.id<y.id;
    return x.cnt>y.cnt;
}

int main()
{
    int n,i,j,k,x,y,z,m,len;
    int ll,l_word,flag;
    int ll2,l_word2;
    while(~scanf("%d",&n),n)
    {
        for(i = 0; i<n; i++)
        {
            getchar();
            gets(s[i].name);
            scanf("%d",&s[i].cnt);
            s[i].id = i;
            s[i].len = strlen(s[i].name);
            s[i].name[s[i].len++] = ' ';
            s[i].name[s[i].len] = '\0';
        }
        sort(s,s+n,cmp);//先排序
        scanf("%d",&m);
        getchar();
        for(i = 0; i<m; i++)//m次查询
        {
            gets(ss);
            ll = 0;
            l_word = 0;
            len = strlen(ss);
            ss[len++] = ' ';
            ss[len] = '\0';
            for(j = 0; j<len; j++)/
            {
                if(ss[j]>='A' && ss[j]<='Z')
                    ss[j]+=32;
            }
            memset(word,'\0',sizeof(word));
            for(j = 0; j<len; j++)//将关键字内的单词都放入word
            {
                if(ss[j]>='a' && ss[j]<='z')
                {
                    word[l_word].name[ll++] = ss[j];
                }
                else if(j>0 && ss[j] == ' ' && ss[j-1]>='a' && ss[j-1]<='z')
                {
                    word[l_word].name[ll] = '\0';
                    word[l_word].len = ll;
                    l_word++;
                    ll = 0;
                }
            }
            for(j = 0; j<n; j++)
            {
                l_word2 = ll2 = 0;
                memset(word2,'\0',sizeof(word2));
                for(k = 0; k<s[j].len; k++)//将句子里的单词放入word2
                {
                    if(s[j].name[k]>='a' && s[j].name[k]<='z')
                    {
                        word2[l_word2].name[ll2++] = s[j].name[k];
                    }
                    else if(s[j].name[k]>='A' && s[j].name[k]<='Z')
                    {
                        word2[l_word2].name[ll2++] = s[j].name[k]+32;
                    }
                    else if(s[j].name[k] == ' ' && s[j].name[k-1]>='a' && s[j].name[k-1]<='z')
                    {
                        word2[l_word2].name[ll2] = '\0';
                        word2[l_word2].len = ll2;
                        l_word2++;
                        ll2 = 0;
                    }
                    else if(s[j].name[k] == ' ' && s[j].name[k-1]>='A' && s[j].name[k-1]<='Z')
                    {
                        word2[l_word2].name[ll2] = '\0';
                        word2[l_word2].len = ll2;
                        l_word2++;
                        ll2 = 0;
                    }
                }
                y = 0;
                x = 0;
                flag = 0;
                while(x<l_word && y<l_word2)//看这个句子是否有关键词
                {
                    if(!strcmp(word[x].name,word2[y].name))//单词吻合，都看向下一个单词，吻合个数加1
                    {
                        x++;
                        y++;
                        flag++;
                    }
                    else//不吻合，重新计算吻合个数，句子的单词往后移一个，关键字的单词重第一个开始
                    {
                        x = 0;
                        y++;
                        flag = 0;
                    }
                }
                if(flag == l_word)//全部吻合则输出
                {
                    for(z = 0;z<s[j].len-1;z++)
                    printf("%c",s[j].name[z]);
                    printf("\n");
                }
            }
            printf("***\n");
        }
        printf("---\n");
    }

    return 0;
}