问题 [NOIP2011 普及组] 统计单词数

题目描述

一般的文本编辑器都有查找单词的功能，该功能可以快速定位特定单词在文章中的位置，有的还能统计出特定单词在文章中出现的次数。

现在，请你编程实现这一功能，具体要求是：给定一个单词，请你输出它在给定的文章中出现的次数和第一次出现的位置。注意：匹配单词时，不区分大小写，但要求完全匹配，即给定单词必须与文章中的某一独立单词在不区分大小写的情况下完全相同（参见样例 1），如果给定单词仅是文章中某一单词的一部分则不算匹配（参见样例 2）。

输入格式

共 $2$ 行。

第 $1$ 行为一个字符串，其中只含字母，表示给定单词；

第 $2$ 行为一个字符串，其中只可能包含字母和空格，表示给定的文章。

输出格式

一行，如果在文章中找到给定单词则输出两个整数，两个整数之间用一个空格隔开，分别是单词在文章中出现的次数和第一次出现的位置（即在文章中第一次出现时，单词首字母在文章中的位置，位置从 $0$ 开始）；如果单词在文章中没有出现，则直接输出一个整数 $-1$。

样例 #1

样例输入 #1

To
to be or not to be is a question

样例输出 #1

2 0

样例 #2

样例输入 #2

to
Did the Ottoman Empire lose its power at that time

样例输出 #2

-1

提示

数据范围

$1\le$ 第一行单词长度 $\le 10$。

$1\le$ 文章长度 $\le 10^6$。

noip2011 普及组第 2 题

我的错误代码

/**
 * CodeForces->力扣+洛谷+牛客->竞赛6P <训练>
 * CodeForces，力扣，牛客，洛谷，ZZULIOJ等 <比赛>
 * 
 * 专注，行动，坚持，争分夺秒——算法竞赛金牌！！！
 * 
 * 一心一意，10000小时，每天10小时+，两年九个月
*/

// 算法竞赛入门经典系列源码解析
    // 算法竞赛入门经典第2版 P
    // 算法竞赛入门经典 习题与解答 P
    // 算法竞赛入门经典 训练指南 P
    // 算法竞赛入门经典 算法实现 P
// 程序设计竞赛训练营
    // 基础与数学概念 P
    // 算法与实践 P
// 牛客练习
// 洛谷练习 P1308 [NOIP2011 普及组] 统计单词数
// 力扣练习 
// CodeForces 

/*
    Dreams never shine!
    It's you that shine while chasing your dreams :)
    JAYO!!
*/

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

void LowerCase(string & str) {
    
    for (auto it = str.begin(); it != str.end(); it++) {
    
        *it = tolower(*it);
    }
}

int main() {
    
    string word, tmp;
    vector<string> text;
    int flag = 0;
    int index, i = -1;
    char ch;
    
    cin >> word;
    LowerCase(word);

    while (cin >> tmp) {
    
        ch = getchar();
        if (ch == '\n') break;
        LowerCase(tmp);
        i++;
        if (word == tmp) {
     
            if (flag == 0) {
    
                index = i;
            }
            flag++;
        }
        text.push_back(tmp);
    }

    if (flag) {
    
        cout << flag << " ";
        int sum = 0;
        for (auto m : text) {
    
            if (index == 0) break;
            sum += m.size();
            index--;
        }
        cout << sum << endl;
    }
    else cout << -1 << endl;
    

    return 0;
}

大神代码1

#include <cstring>
#include <cctype>
#include <cstdio>

void strlower (char *a) {
    //手写函数，将大写字母转换成小写字母
    for(int i = 0; a[i]; i ++ ) {
    
        if(isupper(a[i])) a[i] = tolower(a[i]);//isupper是判断是否是大写字母的系统函数，tolower是将其转换成小写字母的函数
    }
}

int main () {
    

    char destination[1000001], *q, source[11], *p;//destintion是要找的文章，source是要找的单词，p和q都是指针类，分别代表当前搜索到什么地方了和最后一次找到单词的指针
    bool flag = false;//判断是否找到了
    int ans = 0, ans1 = -1;//个数和首次出现的位置，ans1的初值是-1是因为在没找到的时候就直接输出就行了，省事

    gets(source);
    gets(destination);//输入

    strlower(destination);//全部转换成小写字母
    strlower(source);

    int len = strlen(source);//长度，在后面防止越界和加快速度

    p = destination;//先将指针设为全部

    for(; q = strstr(p, source); ) {
    //循环，strstr是在一个字符串里面给定一个字符串，寻找有没有这个字符串，若有，返回首次出现的指针否则返回NULL（空指针）
        if( q != NULL//找到了 
        && ( q == destination || *(q - 1) == ' ') //第一个条件是防止越界，第二个是判断前一个是不是空格
        && ( *(q + len) == '\0' || *(q + len) == ' ' ) ) {
    //如果后面也是空格
            ans ++ ;//答案加一
            if(flag == false) {
    //如果是首次找到
                flag = true;
                ans1 = q - destination;//第一个位置
            }
        }
        p = q + len;//刷新指针
    }

    if(flag == true)//找到了
        printf("%d %d" , ans, ans1);//输出
    else 
        printf("%d", ans1);//输出-1

    return 0;
}

大神代码2

第二种做法 有穷自动机

图灵机大概就是一个“自动机”，就是说代码分好几种状态，每种状态做不同的事。

举个简单的例子吧

输入一个字符串，输入的只有两种字符，一种是字母，一种是空格。现在求一共有几个单词。注意，有可能有多个空格连在一起，开头和结尾都有可能有空格。

那么这是一道简单的有穷自动机，运行时分两种情况：

①是空格

②是字母

（其实当前状态就是上一个字符的状态

那么在遍历数组的时候拿一个变量记录下来当前是什么状态，可以用00代表当前是空格状态，11代表是字母状态

当如果当前状态是11，而现在却遇到空格，那么就计数器加一，同时要将状态改为00，如果当前状态是00，现在的字符却是字母，就只将状态改为11
BUT!
在跳出循环的时候如果状态是11，要将计数器加一，否则如果最后是字母就会少统计一个单词！（想想为什么）

有穷自动机例题【非本篇题目代码】

输入一个字符串，输入的只有两种字符，一种是字母，一种是空格。现在求一共有几个单词。注意，有可能有多个空格连在一起，开头和结尾都有可能有空格。

#include <cstdio>

int main () {
    

    char a[1001];
    int state, ans = 0;

    gets(a);

    if(a[0] == ' ') state = 0;//设置初始值
    else state = 1;

    for(int i = 1; a[i]; i ++ ) {
    //要从一开始遍历，因为零已经遍历过了
        if(a[i] == ' ') {
    //是空格
            if(state == 1) {
    //当前状态（前一个）是字母，说明找到一个单词了
                ans ++ ;//答案加一
                state = 0;//千万别忘了改状态
            }
        }
        else {
    //是字母
            if(state == 0) {
    //当前状态（前一个）是空格
                state = 1;//将状态改为1
            }
        }
    }

    if(state == 1)//最后还要判断一下千万不要忘记
        ans ++ ;
    printf("%d", ans);

    return 0;
}

那么，这就是简单的自动机代码，现在看看本题用自动机如何做

其实一样，就是注意字母状态分时要查找单词状态和不是要查找单词状态，而且单词第nn个字母的状态就用nn来表示

以下是code：

#include <cstdio>
#include <cctype>
#include <cstring>

const int SPACE = 0;   //三种状态，这是空格状态
const int LETTER = -1; //字母状态，但这表示不是要查找的单词的字母的状态
const int WORD = 1;    //而这种状态是要查找的单词的状态
//当然了，如果状态时大于1的数，说明是要查找的单词的中间部分的状态，上文讲过了

inline void strlower(char *a)
{
     //不解释，上面的代码有了
    for (int i = 0; a[i]; i++)
    {
    
        if (isupper(a[i]))
            a[i] = tolower(a[i]);
    }
}

int main()
{
    

    char a[1000001], word[20];
    int ans = 0;
    int ans2 = -1;
    int state = 0; //表状态，假设是空格，因为空格上来就判断是不是三种状态
    int i;

    gets(word);
    gets(a);
    strlower(a);
    strlower(word);
    int len = strlen(word);

    for (i = 0; a[i]; i++)
    {
     //遍历数组
        switch (state)
        {
    
        case SPACE: //如果当前状态（上一个）是空格
            if (a[i] == word[0])
                state = WORD; //变成单词第一个字母状态
            else if (a[i] == ' ')
                state = SPACE; //其实这句话可以省略，因为反正都是空格状态，改它是一样的
            else
                state = LETTER; //剩下的肯定是其他字母状态了
            break;
        case LETTER: //是其他字母状态
            if (a[i] == ' ')
                state = SPACE; //空格状态
            break;
        default: //是要查找的单词状态
            if (state < len)
            {
     //还不是最后一个字母
                if (a[i] == ' ')
                    state = SPACE;
                else if (a[i] == word[state])
                    state++; //变成下一个字母状态
                else
                    state = LETTER; //其他字母状态
            }
            else if (state == len) //是最后一个字母
            {
    
                if (a[i] == ' ')
                {
                           //如果下一个是空格，找到了！
                    state = SPACE;      //状态不要忘记改变
                    if (ans2 == -1)     //第一次找到，记录下来位置
                        ans2 = i - len; //因为i是单词的尾，所以要减长度
                    ans++;              //个数加一
                }
                else
                    state = LETTER; //可惜，最后跟着其他字母，不是单词
            }
        }
    }

    if (state == len)
    {
    
        ans++;
        if (ans2 == -1)
            ans2 = i - 1 - len;
    }
    if (ans2 == -1)
        printf("-1");
    else
        printf("%d %d", ans, ans2);

    return 0;
}

大神方法3

非常帮的想法

    //因为连起来的不算，所以要在前后加几个空格，一定要是同样多的，同量减同量，等于同量
    a=' '+a+' ';
    b=' '+b+' ';

//我的代码比较结构化，容易理解
//在此也建议大家多用用string类，c++有关于string的特大好处，c和pascal都没有哦
//
//定义头文件
#include <iostream>
#include <string>
//命名空间
using namespace std;
int main(){
    
    //定义两个字符串
    string a;
    string b;
    //用string库，调用getline, 直接读入一整行
    getline(cin,a);
    getline(cin,b);
    //转换大小写，可以都转换为大写，或者小写
    for (int i=0;i<a.length();++i){
    
        a[i]=tolower(a[i]);
    }
    for (int i=0;i<b.length();++i){
    
        b[i]=tolower(b[i]);
    }
    //因为连起来的不算，所以要在前后加几个空格，一定要是同样多的，同量减同量，等于同量
    a=' '+a+' ';
    b=' '+b+' ';
    //先看看会不会找不到，用a.find()和string::npos
    if (b.find(a)==string::npos){
    
        cout<<-1<<endl;
    }
    //如果找得到
    else {
    
        int alpha=b.find(a);
        int beta=b.find(a),s=0;//计数器初始化为0
        while (beta!=string::npos){
    
            ++s;//计数器
            beta=b.find(a,beta+1);
        }
        cout<<s<<" "<<alpha<<endl;//输出第一个和总共有几个
    }
    //函数返回值为0，结束整个程序
    return 0;
}

大神代码n

transform 函数

template<typename _InputIterator, typename _OutputIterator, typename _UnaryOperation> _OutputIterator transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __unary_op) {
     }
输入是区间的__first－__last的一段区间，
对这段区间的数据利用__unary_op函数进行操作，
然后将结果放入到__result中。

template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator, typename _BinaryOperation> _OutputIterator transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _OutputIterator __result, _BinaryOperation __binary_op) {
     }
第一个输入区间依旧是__first－__last这一段，
第二个输入是__first2开始取(__last-__first)这一段长度的数据，
对这两段的数据进行__binary_op操作，
然后将结果存入到__result中。
__first是第一段区间的开始
__last是第二段区间的结束
__first2是第二段区间的开始，
在第二个区间开始处向后取__last-__first长度的数据
__result是存储结果的区间开始
__binary_op是对这段数据进行操作的函数，
相当于lambda函数。

C++string中的insert()插入函数

basic_string& insert (size_type pos, const basic_string& str);
在原串下标为pos的字符前插入字符串str

basic_string& insert (size_type pos, const basic_string& str, size_type pos1, size_type n);
str从下标为pos1开始数的n个字符插在原串下标为pos的字符前

basic_string& insert (size_type pos, size_type n, char c);
在原串下标为pos的字符前插入n个字符c


#include<iostream>
using namespace std;
int main()
{
    
    string str="hello";
    string s="Hahah";
    str.insert(1,s);//在原串下标为1的字符e前插入字符串s
    cout<<str<<endl;

    string str1="hello";
    char c='w';
    str1.insert(4,5,c);//在原串下标为4的字符o前插入5个字符c
    cout<<str1<<endl;

    string str2="hello";
    string s2="weakhaha";
    str2.insert(0,s2,1,3);//将字符串s2从下标为1的e开始数3个字符，分别是eak，插入原串的下标为0的字符h前
    cout<<str2<<endl;

    return 0;
}

#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
using namespace std;
int main()
{
    
    string word, text;
    cin >> word;
    getchar();                                           //其实我不知道要不要吞回车
    transform(word.begin(), word.end(), word.begin(), ::tolower); //使a小写化
    getline(cin, text);
    text.insert(text.begin(), ' '); //让b前面加个空格 之后用find不怕查不到第一个
    text = text + ' ';
    word = word + ' ';
    word.insert(word.begin(), ' ');                            //查找的话以首尾加空格，否则可能查找到其他单词里的字符相同但不是个单独的单词
    transform(text.begin(), text.end(), text.begin(), ::tolower); //小写化
    if (text.find(word) == -1)
    {
    
        cout << "-1";
    }
    else
    {
    
        int sum = 0;
        int n = 0;
        while (text.find(word, n) != -1) // find找不到会返回npos也就是-1
        {
    
            sum++;
            n = text.find(word, n) + 1; //剩下都好理解
        }
        cout << sum << " ";
        cout << text.find(word);
    }
}

总结

一题多解，及时复习巩固Anki!!!