Question

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

我几乎解决了它（在C ++中），但是我得到了一些超时，所以我看了官方解决方案，它是用Dlang编写的。

然后我试图模仿官方答案在D中做了什么，但我仍然得到超时（单次输入时> 4秒）。 Afaik，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);
}

然后这是我在C ++中用答案代码编写的内容

#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;
}

在C ++上输入的时间超过5秒，在D上的瞬间输入可以在这里找到＆＃34; http://ddl3.data.hu/get/356808/10699419/s4.24.in＆＃34;

这是我实际上试图解决的问题＆＃34; https://dmoj.ca/problem/ccc17s4＆＃34;（我只做了11分）。

有什么办法可以像D代码一样快速地生成我的C ++代码吗？为什么我的C ++代码运行得和D代码一样快？

编辑：对于所有的澄清，g ++用于C ++而没有任何优化，并且＆＃39; dmd＆＃39;对于Dlang，没有任何优化

Answer 1

find()似乎被大量使用，它们在D和C ++实现中非常不同：

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

VS

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

D中的

find()修改了数组（看起来像某种动态编程，你是否兑现了之前的结果），而在C ++中你总是进行完全查找。你应该比较苹果和苹果，特别是这些代码可以在C ++中用完全相同的方式编写。

Answer 2

出于好奇，我尝试运行OP代码，以及下面的版本，我通过最小化调整'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);
}

Answer 3

C ++版本性能下降的一个可能原因是'inc'功能。它按值接收2个'Edge'结构，在C ++中意味着在排序调用期间为main（）结束时的每次比较复制结构。

尝试更改'inc'的签名以接受'const Edge＆amp;'而不是'边缘'。这将导致struct值通过引用传递，因此避免额外复制。

此外，如果您运行探查器，您应该能够找到大部分时间花在哪里。这是实现优化的“正确”方法：衡量找到性能瓶颈的位置，解决瓶颈并再次测量以确认您确实提高了性能。

D-lang比C ++更快？

3 个答案: