C++ char类型转string类型的两种方法

`string`类选用字节(`char`)作为它的字符类型，那么`string`其实就是一个`char`数组。

通过`string`类的构造函数进行转换

Example

// string constructor
#include <iostream>
#include <string>

int main ()
{
    
    
  std::string s0 ("Initial string");

  // constructors used in the same order as described above:
  std::string s1;
  std::string s2 (s0);
  std::string s3 (s0, 8, 3);
  std::string s4 ("A character sequence");
  std::string s5 ("Another character sequence", 12);
  std::string s6a (10, 'x');
  std::string s6b (10, 42);      // 42 is the ASCII code for '*'
  std::string s7 (s0.begin(), s0.begin()+7);

  std::cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3;
  std::cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6a: " << s6a;
  std::cout << "\ns6b: " << s6b << "\ns7: " << s7 << '\n';
  return 0;
}

output

s1: 
s2: Initial string
s3: str
s4: A character sequence
s5: Another char
s6a: xxxxxxxxxx
s6b: **********
s7: Initial

通过`void push_back (char c);`进行转换

作用：将字符c附加到string的末尾，将其长度增加一。

string g[N];
string s;
s.push_back(g[i][j]);

例题：哞加密(USACO 2015 US Open Bronze)

许多人都不知道，奶牛很喜欢拼图，特别是单词拼图。

农夫约翰的奶牛最近发明了一个有趣的“单词查找器”拼图。

这种拼图的一个例子是：

USOPEN
OOMABO
MOOMXO
PQMROM

作为奶牛，它们唯一感兴趣的单词是 MOO，它可以在拼图中多次沿水平、垂直、45度斜线或135度斜线出现。

上例中，MOO一共出现了 6 次。

农夫约翰也是个拼图迷，由于奶牛们不希望他在它们之前解决“单词查找器”拼图，因此它们使用”替换密码“对内容进行了加密。

该“替换密码”用不同的字母替换了字母表中的每个字母。

例如， $A$ 可以映射到 $X$ ， $B$ 可以映射到 $A$ ，依此类推。

没有字母映射到自身，也没有两个字母映射到同一个字母（否则解将是不明确的）。

不幸的是，奶牛忘记了替换密码的具体加密方式。

请帮助它们确定如果使用适当的替换密码解密，谜题中可能存在的最大MOO数。

输入格式
第一行包含 $N, M$ ，表示拼图的尺寸为 $N$ 行 $M$ 列。

接下来 $N$ 行，每行包含 $M$ 个大写字母，形容加密后的拼图。

输出格式
输出如果使用适当的替换密码解密，谜题中可能存在的最大MOO数。

数据范围
$1 \leq N, M \leq 50$
输入样例：

4 6
TAMHGI
MMQVWM
QMMQSM
HBQUMQ

输出样例：

样例解释
在此样例中， $M$ 和 $O$ 分别被替换为了 $Q$ 和 $M$ 。

以此解密最多可存在 6 个MOO。

本题就是枚举+哈希
Answer:

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <unordered_map>

using namespace std;

const int N = 55;

int n, m;
string g[N];

int main()
{
    
    
    cin >> n >> m;
    for (int i = 0; i < n; i ++) cin >> g[i];
    
    int dx[8] = {
    
    -1, -1, -1, 0, 1, 1, 1, 0};
    int dy[8] = {
    
    -1, 0, 1, 1, 1, 0, -1, -1};
    
    unordered_map<string, int> hash;
    for (int i = 0; i < n; i ++)
    {
    
    
        for (int j = 0; j < m; j ++)
        {
    
    
            for (int k = 0; k < 8; k ++)
            {
    
    
                int x = i, y = j;
                string s(1, g[x][y]);
                
                bool flag = true;
                for (int u = 0; u < 2; u ++)
                {
    
    
                    x += dx[k], y += dy[k];
                    if (x < 0 || x >= n || y < 0 || y >= m)
                    {
    
    
                        flag = false;
                        break;
                    }
                    s += g[x][y];
                }
                
                if (flag && s[0] != s[1] && s[1] == s[2] && s[0] != 'M' && s[1] != 'O')
                    hash[s] ++;
            }
        }
    }
    
    int res = 0;
    for (auto& [k, v] : hash)
        res = max(res, v);
    cout << res << endl;
    return 0;
}