C++ D-lang比C++；？

所以我在为即将到来的算法编程竞赛做练习，我偶然发现了前一年的一个问题

我几乎用C++解决了这个问题，但是我遇到了一些超时问题，所以我看了一下官方的解决方案，它是用Dlang编写的

然后我试着模仿官方答案在D中所做的，但我仍然得到超时（单个输入大于4秒）。另外，C++的速度比D快，但是D在一秒钟内解决了相同的输入，C++对其

需要5秒以上。 这是D答案代码

import std.stdio;
import std.algorithm;

struct edge {
    int src, des, w, o;

    int opCmp (ref const edge e) const {
        if(w != e.w) return w - e.w;
        else return o - e.o;
    }
};

const int MAXN = 100004, MAXM = 200004;
int N, M, D, ee, weight, days;
int[MAXN] ds;
edge[] edges;

void init() {
    for(int i=1;i<=N;i++) ds[i] = i;
}

int find(int x) {
    return ds[x] = (x == ds[x] ? x: find(ds[x]));
}

bool connected(int x, int y) {
    return find(x) == find(y);
}

bool merge(int x, int y) {
    int xr = find(x), yr = find(y);
    if(xr ^ yr) {
        ds[xr] = yr;
        return 1;
    }
    return 0;
}

void main() {
    scanf("%d%d%d", &N, &M, &D);
    for(int i=1, a, b, c;i<=M;i++) {
        scanf("%d%d%d", &a, &b, &c);
        if(i < N)
            edges ~= edge(a, b, c, 0);
        else
            edges ~= edge(a, b, c, 1);
    }
    edges.sort();
    init();
    int i, maxe=0;
    for(i=0;i<edges.length;i++) {
        auto e = edges[i];
        if(merge(e.src, e.des)) {
            if(e.o)
                days ++;
        }
    }
    printf("%d", days);
}

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

struct Edge{
    long long source, end, weight, old;
    Edge(long long _s, long long _e, long long _w, long long _o):source(_s), end(_e), weight(_w), old(_o){}
};

int parents[100004];
vector<Edge>edges;

bool inc(Edge a, Edge b)
{
    if(a.weight == b.weight)return a.old > b.old;
    return a.weight < b.weight;
}

long long find(long long node)
{
    if(parents[node] == node)return node;
    else return find(parents[node]);
}

void init(long long M)
{
    for(long long i = 0; i < M; ++i)parents[i] = i;
}

bool connect(long long x, long long y)
{
    long long fx = find(x);
    long long fy = find(y);
    if(fx == fy)return false;
    parents[fx] = fy;
    return true;
}

long long noOfDays()
{
    long long days = 0;
    for(auto edge : edges){
        if(connect(edge.source, edge.end)){
            if(!edge.old)++days;
        }
    }
    return days;
}

int main()
{
    ios::sync_with_stdio(false); 
    long long N, M , D;
    cin >> N >> M >> D;
    N--;
    for(long long i = 0; i < M; ++i){
        long long a,b,c;
        cin >> a >> b >> c;
        if(i < N){
            edges.push_back(Edge(a,b,c,1));
        }else{
            edges.push_back(Edge(a,b,c,0));         
        }
    }
    sort(edges.begin(), edges.end(), inc);
    init(N+2);
    cout << noOfDays() << endl;
}

导入标准stdio；
导入标准算法；
结构边{
内部src、des、w、o；
int opCmp（参考常数边e）常数{
如果（w！=e.w）返回w-e.w；
否则返回o-e.o；
}
};
常数int MAXN=100004，MAXM=200004；
整数N、M、D、ee、重量、天数；
int[MAXN]ds；
边[]边；
void init（）{
对于（int i＝1；i）C++版本慢性能的一个可能贡献者是“INC”函数。它按值接收2’边’结构，在C++中，这意味着在排序调用的主体（）/P>的排序过程中，每次比较时，都要对结构进行复制。
尝试将“inc”的签名更改为接受“const Edge&”而不是“Edge”。这将导致通过引用传递结构值，从而避免额外的复制

此外，如果您运行探查器，您应该能够找到大部分时间都花在了哪里。这是实现优化的“正确”方法：测量以找到性能瓶颈，解决瓶颈，然后再次测量以确认您确实提高了性能。
find（） >在C++和C++实现中有很大的不同：

int find(int x) {
    return ds[x] = (x == ds[x] ? x: find(ds[x]));
}

vs:

D中的
find（）
修改数组（看起来像某种动态规划，是否兑现了以前的结果）在C++中，你总是做完全查找。你应该把苹果和苹果比较，特别是这个代码可以用C++完全相同的方式写。< /P> < P>出于好奇，我尝试运行OPS代码，还有下面的版本，我通过最小调整'D’代码来创建，以便它在C++下编译。OPS C++版本花费了大约12秒。运行。下面的版本运行大约需要0.25秒

我的结论是，问题的答案是，OP所看到的运行时间的差异可能是由于在一些其他答案中所描述的执行上的差异，而不是C++的性能差。
#include <cstdio>
#include <vector>
#include <algorithm>

struct edge {
    edge(int src, int des, int w, int o) : src(src), des(des), w(w), o(o) {}

    int src, des, w, o;

    int opCmp(const edge& e) const {
        if (w != e.w) return w - e.w;
        else return o - e.o;
    }
};

const int MAXN = 100004, MAXM = 200004;
int N, M, D, ee, weight, days;
int ds[MAXN];
std::vector<edge> edges;

void init() {
    for (int i = 1; i <= N; i++) ds[i] = i;
}

int find(int x) {
    return ds[x] = (x == ds[x] ? x : find(ds[x]));
}

bool connected(int x, int y) {
    return find(x) == find(y);
}

bool merge(int x, int y) {
    int xr = find(x), yr = find(y);
    if (xr ^ yr) {
        ds[xr] = yr;
        return 1;
    }
    return 0;
}

void main() {
    std::scanf("%d%d%d", &N, &M, &D);
    for (int i = 1, a, b, c; i <= M; i++) {
        scanf("%d%d%d", &a, &b, &c);
        if (i < N)
            edges.push_back(edge(a, b, c, 0));
        else
            edges.push_back(edge(a, b, c, 1));
    }
    std::sort(edges.begin(), edges.end(), [](const edge& lhs, const edge& rhs) { return lhs.opCmp(rhs) < 0; });
    init();
    int i, maxe = 0;
    for (i = 0; i<edges.size(); i++) {
        auto e = edges[i];
        if (merge(e.src, e.des)) {
            if (e.o)
                days++;
        }
    }
    printf("%d", days);
}

#包括
#包括
#包括
结构边{
边（intsrc，intdes，intw，into）：src（src），des（des），w（w），o（o）{
内部src、des、w、o；
int opCmp（常数边和e）常数{
如果（w！=e.w）返回w-e.w；
否则返回o-e.o；
}
};
常数int MAXN=100004，MAXM=200004；
整数N、M、D、ee、重量、天数；
int-ds[MAXN]；
向量边；
void init（）{
对于（int i＝1），您是否编译了优化？可能站点对C++有不同的时间限制，D.看起来需要执行一些分析来查看C++代码中的瓶颈所在。@ Mangy- C++：<代码>边缘。在……<代码> >和>代码>边之前保留（m）<代码>。
而不是
边缘。push_back（）
？为什么您的代码段如此不同？不同的逻辑流？不同的名称？很难比较为什么一个比另一个快…我怀疑这会造成如此大的差异（使以前的结果可重用很可能应该读取缓存）
#include <cstdio>
#include <vector>
#include <algorithm>

struct edge {
    edge(int src, int des, int w, int o) : src(src), des(des), w(w), o(o) {}

    int src, des, w, o;

    int opCmp(const edge& e) const {
        if (w != e.w) return w - e.w;
        else return o - e.o;
    }
};

const int MAXN = 100004, MAXM = 200004;
int N, M, D, ee, weight, days;
int ds[MAXN];
std::vector<edge> edges;

void init() {
    for (int i = 1; i <= N; i++) ds[i] = i;
}

int find(int x) {
    return ds[x] = (x == ds[x] ? x : find(ds[x]));
}

bool connected(int x, int y) {
    return find(x) == find(y);
}

bool merge(int x, int y) {
    int xr = find(x), yr = find(y);
    if (xr ^ yr) {
        ds[xr] = yr;
        return 1;
    }
    return 0;
}

void main() {
    std::scanf("%d%d%d", &N, &M, &D);
    for (int i = 1, a, b, c; i <= M; i++) {
        scanf("%d%d%d", &a, &b, &c);
        if (i < N)
            edges.push_back(edge(a, b, c, 0));
        else
            edges.push_back(edge(a, b, c, 1));
    }
    std::sort(edges.begin(), edges.end(), [](const edge& lhs, const edge& rhs) { return lhs.opCmp(rhs) < 0; });
    init();
    int i, maxe = 0;
    for (i = 0; i<edges.size(); i++) {
        auto e = edges[i];
        if (merge(e.src, e.des)) {
            if (e.o)
                days++;
        }
    }
    printf("%d", days);
}