c++输入一个值，若与已有的值重复，则不能被加入

可以使用 STL 中的 set 来实现此功能，set 可以自动去重。

具体实现代码如下：

#include <iostream>
#include <set>

using namespace std;

int main() {
    set<int> s;
    int n;
    while (cin >> n) {
        if (s.count(n)) {
            cout << "该值已存在，不能被加入" << endl;
        } else {
            s.insert(n);
            cout << "加入成功" << endl;
        }
    }
    return 0;
}

在上面的代码中，我们使用 set 来存储已有的值，每次输入一个新值时，首先判断该值是否已经存在于 set 中，如果存在，输出提示信息；如果不存在，将该值加入 set 中，并输出成功信息。

相关问题

C++输入一个字符串，字符串全部由大写英文字母组成、在字符串中’C、’S’、’P’是一个组合，不需要考虑组合顺序，且字符不可以重复使用。输出可以组合多少CSP的组合。

这个问题可以通过回溯法来解决。我们可以遍历字符串中的每个字符，然后对每个字符进行选择或者不选择。

具体的算法如下：

1. 初始化一个计数器`count`为0，表示CSP组合的数量。
2. 定义一个递归函数`backtrack`，该函数有三个参数：当前处理的位置`index`，当前已选择的字符集合`chosen`，字符串`s`。
3. 在递归函数中，首先判断如果`chosen`中包含了'C'、'S'和'P'这三个字符，那么说明找到了一个CSP组合，将计数器`count`加1。
4. 然后遍历从`index`开始到字符串末尾的每个字符，如果当前字符不在`chosen`中，那么将其加入`chosen`中，然后递归调用`backtrack`函数，处理下一个位置`index+1`。
5. 处理完当前位置后，需要将当前字符从`chosen`中移除，以便处理下一个字符。
6. 最后，返回计数器`count`的值作为结果。

下面是一个使用C++实现的示例代码：

#include <iostream>
#include <unordered_set>
using namespace std;

int countCSP(string s) {
    int count = 0;
    unordered_set<char> chosen;

    // 回溯函数
    function<void(int, unordered_set<char>&)> backtrack = [&](int index, unordered_set<char>& chosen) {
        if (chosen.size() == 3 && chosen.count('C') && chosen.count('S') && chosen.count('P')) {
            count++;
        }
        for (int i = index; i < s.length(); i++) {
            char c = s[i];
            if (chosen.count(c) == 0) {
                chosen.insert(c);
                backtrack(i + 1, chosen);
                chosen.erase(c);
            }
        }
    };

    backtrack(0, chosen);
    return count;
}

int main() {
    string s;
    cout << "请输入由大写英文字母组成的字符串：";
    cin >> s;
    int result = countCSP(s);
    cout << "可以组合的CSP的组合数量为：" << result << endl;
    return 0;
}

你可以运行这段代码，并输入一个由大写英文字母组成的字符串，程序将输出可以组合的CSP的组合数量。

用c++编程描述 一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由n * n的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。 输入 第1行是测试数据的组数k，后面跟着k组输入。每组测试数据的第1行是一个正整数n (1 <= n <= 100)，表示迷宫的规模是n * n的。接下来是一个n * n的矩阵，矩阵中的元素为.或者#。再接下来一行是4个整数ha, la, hb, lb，描述A处在第ha行, 第la列，B处在第hb行, 第lb列。注意到ha, la, hb, lb全部是从0开始计数的。 输出 k行，每行输出对应一个输入。能办到则输出“YES”，否则输出“NO”。

以下是C++代码实现：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

int dx[4] = {0, 0, 1, -1}; // 方向数组
int dy[4] = {1, -1, 0, 0};

bool bfs(vector<vector<char>>& maze, int ha, int la, int hb, int lb) {
    int n = maze.size();
    vector<vector<bool>> visited(n, vector<bool>(n, false));
    queue<pair<int, int>> q; // 存储坐标的队列
    q.push(make_pair(ha, la));
    visited[ha][la] = true;

    while (!q.empty()) {
        auto cur = q.front();
        q.pop();
        if (cur.first == hb && cur.second == lb) {
            return true; // 找到终点
        }
        for (int i = 0; i < 4; i++) {
            int nx = cur.first + dx[i];
            int ny = cur.second + dy[i];
            if (nx >= 0 && nx < n && ny >= 0 && ny < n && maze[nx][ny] == '.' && !visited[nx][ny]) {
                q.push(make_pair(nx, ny));
                visited[nx][ny] = true;
            }
        }
    }
    return false; // 遍历完所有可行路径，未找到终点
}

int main() {
    int k;
    cin >> k;
    while (k--) {
        int n;
        cin >> n;
        vector<vector<char>> maze(n, vector<char>(n));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                cin >> maze[i][j];
            }
        }
        int ha, la, hb, lb;
        cin >> ha >> la >> hb >> lb;
        if (maze[ha][la] == '#' || maze[hb][lb] == '#') {
            cout << "NO" << endl;
            continue;
        }
        if (bfs(maze, ha, la, hb, lb)) {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }
    }
    return 0;
}

解释：

1. 输入数据的组数k，表示有k组测试数据，使用while循环遍历每一组数据。

2. 对于每组数据，首先输入迷宫的规模n，然后输入n * n的矩阵表示迷宫，再输入起点A和终点B的坐标。

3. 如果起点或终点为#，则无法到达，输出NO。

4. 使用BFS遍历迷宫，从起点开始搜索，尝试向四个方向移动，如果移动到的点合法且未被访问过，则将其加入队列中，标记为已访问。重复该过程，直到找到终点或遍历完所有可行路径。

5. 如果找到终点，则输出YES，否则输出NO。

注意：在输入坐标时，题目中指定从0开始计数，需要注意数组下标的对应关系。