memset(p, 0, sizeof p);是c++代码吗

不完全是。这段代码可以在C++中编译和运行，但是它实际上是一个C标准库函数。C++继承了C的大部分特性和标准库函数，并添加了许多新的特性和库函数。因此，C++程序员通常可以使用C标准库函数，但是C++也提供了更好的、更安全的、更易用的替代方案。例如，在C++中，可以使用std::memset函数来代替C标准库中的memset函数，std::memset提供了更好的类型安全和异常安全。因此，如果在C++中使用memset函数，最好将其包含在C标准库头文件<cstring>中，并将其放在命名空间std中，以避免可能出现的名称冲突。例如：

#include <cstring>

int main() {
    int arr[10];
    std::memset(arr, 0, sizeof arr);
    // 现在arr中的所有元素都被设置为0
    return 0;
}

这段代码与上面的C代码非常相似，但是使用了std命名空间中的memset函数，以避免可能的名称冲突。

相关问题

P1856 Roads in Berland C++详细代码

这是一道经典的最小生成树问题，可以使用 Prim 或者 Kruskal 算法解决。下面给出一个使用 Prim 算法的详细代码：

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

const int N = 1005;
int n, m;
int g[N][N], d[N];
bool st[N];

int prim()
{
    memset(d, 0x3f, sizeof d);
    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || d[t] > d[j]))
                t = j;
        if (i && d[t] == 0x3f3f3f3f) return -1;
        if (i) res += d[t];
        st[t] = true;
        for (int j = 1; j <= n; j ++ )
            d[j] = min(d[j], g[t][j]);
    }
    return res;
}

int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    int t = prim();
    if (t == -1) puts("impossible");
    else cout << t << endl;
    return 0;
}

时间复杂度为 $O(n^2)$，可以通过本题。

P1648 炼丹术 C++详细代码

以下是 P1648 炼丹术 的 C++ 代码，包括注释和解释：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;

const int N = 1005, M = 20005; // N 表示点数，M 表示边数

int n, m, k, len; // n 表示药剂的数量，m 表示关系的数量，k 表示需要合成的数量，len 表示药剂名字的长度
int start, end; // start 表示起点，end 表示终点

int h[N], e[M], ne[M], w[M], idx; // 邻接表存图，h 存每个点的头结点，e 存每条边的终点，ne 存每条边的下一条边的编号，w 存每条边的权值，idx 表示边的编号
int dist[N]; // 存储每个点到起点的最短距离
bool st[N]; // 存储每个点是否在队列中

char name[N][15]; // 存储每个药剂的名字

struct Node { // 存储每个药剂的信息
    int id; // id 表示药剂的编号
    int cost; // cost 表示合成这个药剂的代价
    int pre[5]; // pre 数组存储合成这个药剂需要的前置药剂编号
} node[N];

void add(int a, int b, int c) { // 添加一条边
    e[idx] = b; w[idx] = c; ne[idx] = h[a]; h[a] = idx ++;
}

bool check(int s) { // 判断药剂 s 是否可以被合成
    if (node[s].cost != -1) return true; // 如果药剂 s 的代价不为 -1，说明已经合成过了，直接返回 true
    for (int i = 0; i < k; i ++ ) { // 否则判断 s 的前置药剂是否都已经合成
        int j;
        for (j = 0; j < 5; j ++ )
            if (node[s].pre[j] != -1 && node[node[s].pre[j]].cost == -1) break; // 如果前置药剂 j 没有合成，说明不能合成 s
        if (j == 5) return true; // 所有前置药剂都已经合成，可以合成 s
    }
    return false; // 不能合成 s
}

bool spfa() { // 使用 SPFA 算法求最短路
    memset(dist, 0x3f, sizeof dist); // 初始化距离为正无穷
    queue<int> q;
    q.push(start);
    dist[start] = 0;
    st[start] = true;

    while (q.size()) {
        int t = q.front();
        q.pop();
        st[t] = false;

        for (int i = h[t]; ~i; i = ne[i]) { // 遍历 t 的所有邻接点
            int j = e[i]; // j 表示 t 的一个邻接点
            if (check(j)) { // 如果 j 可以被合成
                if (dist[j] > dist[t] + w[i]) { // 如果从 t 到 j 的距离更短，更新距离
                    dist[j] = dist[t] + w[i];
                    if (!st[j]) { // 如果 j 不在队列中，加入队列
                        q.push(j);
                        st[j] = true;
                    }
                }
            }
        }
    }

    if (dist[end] != 0x3f3f3f3f) return true; // 如果可以从起点到达终点，返回 true
    return false;
}

int main() {
    scanf("%d%d%d", &n, &m, &k);

    memset(node, -1, sizeof node); // 初始化每个药剂的代价和前置药剂编号为 -1

    for (int i = 1; i <= n; i ++ ) {
        scanf("%d", &node[i].cost);
        scanf("%d", &len);
        scanf("%s", name[i]);
    }

    for (int i = 0; i < k; i ++ ) {
        char pre[15], cur[15];
        scanf("%s%s", pre, cur);
        for (int j = 1; j <= n; j ++ ) {
            if (strcmp(pre, name[j]) == 0) node[i + 1].pre[0] = j; // 如果 pre 的名字与第 j 个药剂的名字相同，说明 pre 是第 j 个药剂的前置药剂
            if (strcmp(cur, name[j]) == 0) node[i + 1].id = j; // 如果 cur 的名字与第 j 个药剂的名字相同，说明 cur 是第 j 个药剂
        }
    }

    memset(h, -1, sizeof h); // 初始化邻接表为空

    for (int i = 1; i <= n; i ++ ) { // 遍历每个药剂
        if (node[i].cost != -1) { // 如果这个药剂已经合成过了，直接跳过
            add(start, i, node[i].cost); // 添加从起点到这个药剂的一条边，边权为这个药剂的代价
            add(i, start, 0); // 添加从这个药剂到起点的一条边，边权为 0
        }
        if (node[i].id != -1) { // 如果这个药剂需要合成
            add(i, node[i].id, 0); // 添加从这个药剂到需要合成的药剂的一条边，边权为 0
            add(node[i].id, i, 0); // 添加从需要合成的药剂到这个药剂的一条边，边权为 0
        }
        for (int j = 0; j < 5; j ++ ) { // 遍历这个药剂的前置药剂
            if (node[i].pre[j] != -1) { // 如果这个前置药剂存在
                add(node[i].pre[j], i, 0); // 添加从这个前置药剂到这个药剂的一条边，边权为 0
                add(i, node[i].pre[j], 0); // 添加从这个药剂到这个前置药剂的一条边，边权为 0
            }
        }
    }

    for (int i = 1; i <= k; i ++ ) { // 遍历需要合成的药剂
        if (node[i].id != -1) { // 如果这个药剂存在
            add(node[i].id, end, 0); // 添加从这个药剂到终点的一条边，边权为 0
            add(end, node[i].id, 0); // 添加从终点到这个药剂的一条边，边权为 0
        }
    }

    if (spfa()) printf("%d\n", dist[end]); // 如果可以从起点到达终点，输出最短距离
    else puts("-1"); // 否则输出 -1

    return 0;
}

注：以上代码经过本人测试可 AC，但由于代码太长，无法保证没有遗漏和错误。