http://wiki.codeblocks.org/index.php/FAQ-General
Most probably your code is wrong... 8)
The main problem is you do not know the difference between an compiler and a IDE.
Tim S.
my problem is that Code::Blocks gives me a different result from every other IDE i could findwhat are different results?
Care to explain more? Don't just post-hunt.Well, two seconds google, or just 2 sec on wiki would solve this:
-------------- Clean: Release in wtfkruskal (compiler: GNU GCC Compiler)---------------
Cleaned "wtfkruskal - Release"
-------------- Build: Release in wtfkruskal (compiler: GNU GCC Compiler)---------------
mingw32-g++.exe -Wall -fexceptions -O2 -c "D:\code blocks\wtfkruskal\main.cpp" -o obj\Release\main.o
mingw32-g++.exe -o bin\Release\wtfkruskal.exe obj\Release\main.o -s
Output file is bin\Release\wtfkruskal.exe with size 110.00 KB
Process terminated with status 0 (0 minute(s), 5 second(s))
0 error(s), 0 warning(s) (0 minute(s), 5 second(s))
My question is more like why would that happen as long as the code is absolutely the same?It does not happen. If i copy and paste the program from your link into a codeblocks project i get exactly the same output as in the link at the bottom. (but i use gcc 5.x.x)
The program compiles fine, the output is fine structurally, but it's wrong (on all of C++98/C++00/C++11), it should be a different one. I hope you understood what result i was talking about,i still don't know what your output is....
QuoteThe program compiles fine, the output is fine structurally, but it's wrong (on all of C++98/C++00/C++11), it should be a different one. I hope you understood what result i was talking about,i still don't know what your output is....
[edit:] You can copy and paste the output of a console window. Google for it...
// C++ program for Kruskal's algorithm to find Minimum Spanning Tree
// of a given connected, undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// a structure to represent a weighted edge in graph
struct Edge
{
int src, dest, weight;
};
// a structure to represent a connected, undirected
// and weighted graph
struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;
// graph is represented as an array of edges.
// Since the graph is undirected, the edge
// from src to dest is also edge from dest
// to src. Both are counted as 1 edge here.
struct Edge* edge;
};
// Creates a graph with V vertices and E edges
struct Graph* createGraph(int V, int E)
{
struct Graph* graph = new Graph;
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
return graph;
}
// A structure to represent a subset for union-find
struct subset
{
int parent;
int rank;
};
// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i
// (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
// Attach smaller rank tree under root of high
// rank tree (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
// If ranks are same, then make one as root and
// increment its rank by one
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
// The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph* graph)
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
// Step 1: Sort all the edges in non-decreasing
// order of their weight. If we are not allowed to
// change the given graph, we can create a copy of
// array of edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
// Allocate memory for creating V ssubsets
struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );
// Create V subsets with single elements
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;
subsets[v].rank = 0;
}
// Number of edges to be taken is equal to V-1
while (e < V - 1)
{
// Step 2: Pick the smallest edge. And increment
// the index for next iteration
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
// If including this edge does't cause cycle,
// include it in result and increment the index
// of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
// print the contents of result[] to display the
// built MST
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src, result[i].dest,
result[i].weight);
return;
}
// Driver program to test above functions
int main()
{
int V = 9; // Number of vertices in graph
int E = 14; // Number of edges in graph
struct Graph* graph = createGraph(V, E);
graph->edge[0].src = 0;
graph->edge[0].dest = 1;
graph->edge[0].weight = 10;
graph->edge[1].src = 0;
graph->edge[1].dest = 2;
graph->edge[1].weight = -11;
graph->edge[2].src = 1;
graph->edge[2].dest = 3;
graph->edge[2].weight = 11;
graph->edge[3].src = 1;
graph->edge[3].dest = 4;
graph->edge[3].weight = 11;
graph->edge[4].src = 4;
graph->edge[4].dest = 5;
graph->edge[4].weight = 13;
graph->edge[5].src = 2;
graph->edge[5].dest = 3;
graph->edge[5].weight = 10;
graph->edge[6].src = 3;
graph->edge[6].dest = 5;
graph->edge[6].weight = 12;
graph->edge[7].src = 3;
graph->edge[7].dest = 6;
graph->edge[7].weight = 5;
graph->edge[8].src = 2;
graph->edge[8].dest = 6;
graph->edge[8].weight = 4;
graph->edge[9].src = 2;
graph->edge[9].dest = 7;
graph->edge[9].weight = 5;
graph->edge[10].src = 7;
graph->edge[10].dest = 6;
graph->edge[10].weight = 5;
graph->edge[11].src = 7;
graph->edge[11].dest = 8;
graph->edge[11].weight = 4;
graph->edge[12].src = 8;
graph->edge[12].dest = 6;
graph->edge[12].weight = 3;
graph->edge[13].src = 5;
graph->edge[13].dest = 6;
graph->edge[13].weight = 11;
KruskalMST(graph);
return 0;
}
Following are the edges in the constructed MST
3 -- 6 == 5
0 -- 2 == -11
8 -- 6 == 3
7 -- 8 == 4
2 -- 3 == 10
0 -- 1 == 10
5 -- 6 == 11
1 -- 4 == 11
Following are the edges in the constructed MST
0 -- 2 == -11
8 -- 6 == 3
2 -- 6 == 4
7 -- 8 == 4
3 -- 6 == 5
0 -- 1 == 10
1 -- 4 == 11
5 -- 6 == 11
p graph->edge[0]
$1 = {src = 3, dest = 6, weight = 5}
p graph->edge[1]
$2 = {src = 0, dest = 2, weight = -11}
p graph->edge[2]
$3 = {src = 8, dest = 6, weight = 3}
p graph->edge[0]
$2 = {src = 0, dest = 2, weight = -11}
graph->edge[1]]
$4 = {src = 8, dest = 6, weight = 3}
p graph->edge[2]]
$6 = {src = 2, dest = 6, weight = 4}
0: -11
1: 3
2: 4
3: 4
4: 5
5: 5
6: 5
7: 10
8: 10
9: 11
10: 11
11: 11
12: 12
13: 13
0: 5
1: -11
2: 3
3: 4
4: 5
5: 10
6: 5
7: 10
8: 4
9: 11
10: 11
11: 11
12: 12
13: 13
struct {
bool operator()(const Edge a1,const Edge b1) const
{
return a1.weight < b1.weight;
}
} customLess;
std::sort(graph->edge, graph->edge + graph->E, customLess);
0 -- 2 == -11
8 -- 6 == 3
2 -- 6 == 4
7 -- 8 == 4
3 -- 6 == 5
0 -- 1 == 10
1 -- 4 == 11
5 -- 6 == 11
comparison function which returns a negative integer value if the first argument is less than the second,
a positive integer value if the first argument is greater than the second and zero if the arguments are equal.