洛谷C++简单题练习-暴力算法初接触

day3---单词分析---1.17

习题概述

小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。
给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
输入描述
输入一行包含一个单词，单词只由小写英文字母组成。
对于所有的评测用例，输入的单词长度不超过1000
输出描述
输出两行：第一行包含一个英文字母，表示单词中出现得最多的字母是哪个。如果有多个字母出现的次数相等，输出字典序最小的那个。
                  第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。

分析习题：简单暴力——直接按照题意做

要解决这个问题，可以使用一个长度为26的整型数组来记录每个字母出现的次数。数组的索引表示字母在字母表中的位置，初始值都为0。

1.读取输入的单词。 阿拉伯数字

2.遍历单词的每个字母，对应更新字母出现的次数。

3.找到出现次数最多的字母和对应的出现次数。

4.如果有多个字母出现次数相等，选择字典序最小的字母作为结果。

5.输出结果。

代码部分

#include 
#include 
using namespace std;

int main() {
    string word;//声明字符串 
    cin >> word;

    int maxCount = 0;//出现最多次数的字母 
    char maxChar = 'a';//出现次数
// 'a' 遍历到字母 'z'
    for (char c = 'a'; c <= 'z'; c++) {
        int count = 0;//当前字母 c在单词中出现的次数
        for (int i = 0; i < word.size(); i++) {
            if (word[i] == c) {
                count++;
            }
        }
//比较当前字母c的出现次数count和记录的最大次数maxCount的大小
        if (count > maxCount) {
            maxCount = count;
            maxChar = c;
        }
    }
    cout << maxChar << endl;
    cout << maxCount << endl;
    return 0;
}

心得体会

上述这段代码中的"暴力"体现在双重嵌套循环的使用上。具体来说，它通过遍历字母表中的每个字母，然后在内部循环中遍历给定字符串中的每个字符，以统计每个字母在字符串中出现的次数。

这种方法被称为"暴力"，是因为它通过逐个检查每个字符并计算出现次数来解决问题，而没有使用更高效的数据结构或算法来优化。

当谈到暴力算法时，它通常指的是通过穷举所有可能的解来解决问题，而不是使用更高效的优化方法。暴力算法可以看作是一种简单直接的、朴素的解决方案。

下面是一些常见的例子，展示了暴力算法的应用：

1.子集生成：给定一个集合，暴力算法会生成该集合的所有可能的子集。例如，对于一个包含 n 个元素的集合，暴力算法会生成 2^n 个子集。

#include   
#include     
using namespace std; 

// 生成子集的函数
vector> generateSubsets(vector& nums) 
{
    vector> subsets; // 创建存储子集的二维向量
    int n = nums.size();         // 获取原始向量的大小

    for (int i = 0; i < (1 << n); i++) // 通过位运算生成子集的所有可能性
    {                           
        vector subset; // 创建存储单个子集的向量
        for (int j = 0; j < n; j++) //遍历原始向量的元素
        { 
            if ((i >> j) & 1) // 判断当前位是否为1，即该元素是否属于当前子集
            {
                subset.push_back(nums[j]); // 将符合条件的元素加入子集向量中
            }
        }
        subsets.push_back(subset); // 将当前子集加入所有子集的向量中
    }
    return subsets; // 返回所有子集的向量
}

int main() {
    vector nums; // 创建存储原始向量的向量
    nums.push_back(1); // 向原始向量中添加元素1
    nums.push_back(2); // 向原始向量中添加元素2
    nums.push_back(3); // 向原始向量中添加元素3

    // 调用生成子集的函数，将结果保存在二维向量中
    vector> subsets = generateSubsets(nums);

    // 使用范围-based for 循环遍历所有子集
    for (const auto& subset : subsets) 
    {
        // 使用范围-based for 循环遍历子集中的元素
        for (int num : subset) 
        {
            cout << num << " "; // 输出子集中的元素
        }
        cout << endl; 
    }
    return 0;
}

 ①.if ((i >> j) & 1)  这个代码的意思是看当前位是否为1，该元素是否属于当前子集

  1）i是一个整数，表示子集的编码。每个子集可以用一个二进制数来表示，其中每个位表示对应原始向量中的元素是否包含在子集中。

  2）j是一个循环变量，用于遍历每个位的位置

  3）>>是右移位运算符。表达式(i >> j) 将 i 向右移动 j位。

  4）&是按位与运算符。表达式(i >> j) & 1将右移后的结果与二进制数1进行按位与运算。

②      for (const auto& subset : subsets)

   const auto& subset：这部分声明了一个循环变量 subset，它是一个常量引用，用于存储 subsets中的每个元素。

   : 这个冒号表示循环的开始。

   subsets：这是要遍历的向量，即存储了所有子集的向量。

        for (int num : subset)

   int num：这部分声明了一个循环变量 num，它是一个整数，用于存储subset中的每个元素。

         ：这个冒号表示循环的开始。

   subset：这是要遍历的容器，即当前子集。

2.排列组合：暴力算法可以用来生成所有可能的排列或组合。例如，在一个由 n 个元素组成的集合中，暴力算法可以生成 n!个排列。

3.搜索算法：在某些搜索问题中，暴力算法会遍历所有可能的解空间，直到找到目标解。例如，穷举搜索算法可以用于解决八皇后问题。

4.字符串匹配：在字符串匹配问题中，暴力算法会通过遍历主串和模式串的所有可能位置来查找匹配。例如，朴素的字符串匹配算法（也称为暴力算法）会检查主串中的每个位置是否与模式串完全匹配。

预告一波~明日代码讲解洛谷练习哦~

#include 
#include 
using namespace std;

int main() {
    int n;//读一个整数 
    cin >> n;
//qaq用于记录输入数字中非零数字的个数 
    int x, qaq = 0;
    char a;
    
    queue q, qq;
    
    cin >> a;
    while (a != '0') {
        q.push(a);
        qaq += (a - '0');//非零字符的个数累加到变量 qaq 
        cin >> a;
    }

//输出队列q中存储的每个位数
    cout << "输入数字的每个位数：" << endl;
    while (!q.empty()) {
        cout << q.front() << " ";
        qq.push(q.front());
        q.pop();
    }
    cout << endl;

    x = qq.size();//计算队列qq的大小
    cout << "输入数字的非零位数个数：" << qaq << endl;
    cout << "输入数字的位数：" << x << endl;
    
    cout << "转换为十进制表示的式子：" << endl;
    while (!qq.empty()) {
        x--;
        if (qq.front() != '0') {
            qaq--;
            cout << qq.front() << '*' << n << '^' << x;
            if (x != 0 && qaq != 0)
                cout << '+';
        }
        qq.pop();
    }
    cout << endl;

    return 0;
}