Submission #463703

#	Time	Username	Problem	Language	Result	Execution time	Memory
463703		mshandilya	Dreaming (IOI13_dreaming)	C++14	Compilation error	0 ms	0 KiB

dreaming

#include "bits/stdc++.h"
#include "dreaming.h"
#define adj_list vector<list<pair<int, int>>>
#define vi vector<int>
using namespace std;

int nodes;
adj_list adj;
vi max_sub_dist, final_dist, trees;

void dfs1(int root) {
    max_sub_dist[root] = 0;
    for(auto& i : adj[root]) {
        if(max_sub_dist[i.first]==-1) {
            dfs1(i.first);
            max_sub_dist[root] = max(max_sub_dist[root], max_sub_dist[i.first] + i.second);
        }
    }
}

int dfs2(int root) {
    pair<int, int> maxi = make_pair(nodes, 0), smaxi = make_pair(nodes, 0);
    for(auto& i : adj[root]) {
        if(max_sub_dist[i.first]+i.second > max_sub_dist[maxi.first] + maxi.second) {
            smaxi = maxi;
            maxi = i;
        }
        else if(max_sub_dist[i.first]+i.second > max_sub_dist[smaxi.first] + smaxi.second) {
            smaxi = i;
        }
    }
    if(max_sub_dist[smaxi.first] + smaxi.second >= max_sub_dist[maxi.first])
        return root;
    max_sub_dist[maxi.first] = max(max_sub_dist[maxi.first], max_sub_dist[smaxi.first] + smaxi.second + maxi.second);
    max_sub_dist[root] = max_sub_dist[smaxi.first] + smaxi.second;
    return dfs2(maxi.first);
}

int diameter_dfs(int root, int state = 0) {
    int maxi = root, node;
    final_dist[root] = 0;
    for(auto& i : adj[root]) {
        if(final_dist[i.first]==-1) {
            node = diameter_dfs(i.first, 1);
            if(i.second + final_dist[i.first] > final_dist[root]) {
                maxi = node;
                final_dist[root] = i.second + final_dist[i.first];
            }
        }
    }
    if(state)
        return maxi;
    final_dist.assign(nodes, -1);
    diameter_dfs(maxi, 1);
    return maxi;
}

int travelTime(int N, int M, int L, int A[], int B[], int T[]) {
    nodes = N;
    ///constructing adjacency list --> O(N+M) ~ O(2N)
    adj.assign(N, list<pair<int, int>> ());
    for(int i = 0; i<M; i++) {
        adj[A[i]].push_back(make_pair(B[i], T[i]));
        adj[B[i]].push_back(make_pair(A[i], T[i]));
    }
    ///finding the longest existing path from any node and selecting the minimum of those within a connected tree
    ///--> in order to find the longest path and simultaneously select, let us do two dfs such that the first
    /// finds max distance in the subtree and the second finds the overall max distance O(6N)
    max_sub_dist.assign(N+1, -1);
    max_sub_dist[N] = 0;
    int maxi = 0, node;
    for(int i = 0; i<N; i++) {
        if(max_sub_dist[i]==-1) {
            dfs1(i);
            node = dfs2(i);
            if(max_sub_dist[node]>max_sub_dist[maxi])
                maxi = node;
            trees.push_back(node);
        }
    }
    for (auto i : max_sub_dist) {
        cout<<i<<" ";
    }
    cout<<endl;
    for (auto & i : trees) {
        cout<<i<<" ";
    }
    cout<<endl;
    ///since now, we already know the trees that exist, we just need to optimally merge them
    for(int & tree : trees) {
        if(tree!=maxi) {
            adj[tree].push_back(make_pair(maxi, L));
            adj[maxi].push_back(make_pair(tree, L));
        }
    }
    ///now that the trees are merged, let's just find the maximum distance (tree diameter), between any two nodes
    final_dist.assign(N, -1);
    node = diameter_dfs(maxi);
    return final_dist[node];
}

int main() {
    int n, l, m;
    cin>>n>>m>>l;
    int a[m], b[m], t[m];
    for(int i = 0; i<m; i++) {
        cin>>a[i]>>b[i]>>t[i];
    }
    cout<<travelTime(n, m, l, a, b, t)<<endl;
}

Compilation message (stderr)

/usr/bin/ld: /tmp/ccG8kJDJ.o: in function `main':
dreaming.cpp:(.text.startup+0x0): multiple definition of `main'; /tmp/ccd5uJHG.o:grader.c:(.text.startup+0x0): first defined here
collect2: error: ld returned 1 exit status