void init() {
odd = bar, even = last = odd + 1, foo = even + 1;
MST(odd->ch, 0), MST(even->ch, 0);
odd->suffix = even->suffix = odd;
odd->len = -1, even->len = 0;
n = 0, cnt = 0, mx = 0;
}
Graph<T> Graph<T>::Prim( int vertex )
{
const int V = GetVertices();
Graph<int> MST( V );
MinPairHeap Heap;
int current = vertex;
Visited[current] = true;
for( int i = 0; i < V; i++ )
{
std::cout << "current " << current << std::endl;
std::vector< std::pair<int, int> > temp =
FindAllNeighbors( current );
for( int j = 0; j < temp.size(); j++ )
{
if( !Visited[temp[j].first] )
{
Heap.push( temp[j] );
Visited[temp[j].first] = true;
}
}
if( !Heap.empty() )
{
current = Heap.pop().first;
}
else
return MST;
}
return MST;
}
int main()
{
int i,j,k,cas=0,t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&N);
int cnt=0; node.clear();
for(i=1;i<=N;i++)
{
for(j=1;j<=N;j++)
{
scanf("%d",&k);
if(k)
{
cnt+=k;
node.pb(mp(k,mp(i,j)));node.pb(mp(k,mp(j,i)));
}
}
}
sort(all(node));
E_count=0;
int ans=MST();
ans=cnt-ans;
if(E_count<N-1) printf("Case %d: %d\n",++cas,-1);
else printf("Case %d: %d\n",++cas,ans);
}
return 0;
}
void Cal() {
int i, j;
double dis;
M = 0;
for(i = 0; i<N-1; i++) {
for(j = i+1; j<N; j++) {
dis = dist(pp[i].x,pp[i].y,pp[j].x,pp[j].y);
P[M].dis = dis;
P[M].x = i;
P[M++].y = j;
}
}
printf("%.2lf\n",MST());
}
int main() {
while (scanf("%d %d", &N, &M) != EOF) {
for (int i = 0; i < N; i++) fill(dis[i], dis[i] + N, inf);
for (int i = 0; i < M; i++) {
int a, b, val;
scanf("%d %d %d", &a, &b, &val);
a--, b--;
dis[a][b] = dis[b][a] = min(dis[a][b], val);
}
init();
MST(N, 0);
cost2 = inf;
for (int i = 0; i < N; i++) {
fill(vst, vst + N, 0);
dfs(i, i, 1, 0); //基于无重边的算法
}
if (cost2 == inf) cost2 = -1;
printf("Cost: %d\nCost: %d\n", cost, cost2);
}
}
Graph<T> Graph<T>::Kruskal( int vertex )
{
const int V = GetVertices();
Graph<int> MST( V );
MinPairHeap Heap;
std::vector<bool> Visited( Matrix.size(), false );
int current = vertex;
Visited[current] = true;
std::vector< std::pair<int,int> > neighbors =
FindAllNeighbors( vertex );
for( int i = 0; i < neighbors.size(); i++ )
{
Heap.push( neighbors[i] );
}
while( !Heap.empty() )
{
std::pair<int, int> Vert = Heap.pop();
std::cout << Vert.first << std::endl;
}
}
void init(int k)
{
for(int i = 0; i < n; i++) {
for(int j = i + 1; j < n; j++) {
s[i][j] = s[j][i] = g[i][j] = g[j][i] = dis(i,j);
}
}
tot_w = 0;
E = 0;
std::fill(head,head+n,-1) ;
MST();
memset(in,false,sizeof(in));
for(int i = 0; i < n; i++) dfs(i,i,-1);
top = 0;
go(0,-1);
double ans = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) if(in[i][j]&&i&&j){
ans = std::max(ans,opt[i][j]-g[i][j]) ;
}
}
printf("%.2f\n",(tot_w+ans)*k);
}
int main(int argc, char**argv)
{
out("starting ...\n");
std::cout << " Kruskal MST (min spanning tree) " << std::endl;
if(argc > 1 && strncmp(argv[1], "-d", 3))
int g_debug = 1;
int N; //test cases
scanf("%d\n", &N);
out("N %d\n",N);
int ord = 0;
//for Kruskal I used list of edges-weights format
while(N-- > 0) {
char * buff = NULL;
graphtp g;
pqtp pq;
int counter = 0;
int cn; //count of nodes
int ce; //count of edges
scanf("%d %d\n", &cn, &ce);
out("cn %d ce %d\n", cn, ce);
for(int i = 0; i < cn; ++i) {
mwp me;
g.push_back(me);
}
int i = 0;
while(i++ < ce)
{
int nodefrom;
int nodeto;
float weight;
scanf("%d %d %f\n", &nodefrom, &nodeto, &weight); //how many edges
out("%d %d %f\n", nodefrom, nodeto, weight);
if(nodeto < cn) {
//proceed normally
}
else {
printf("ERROR: node %d outside of range (max %d)\n", nodeto,cn);
continue; //skip this edge
}
edge e;
e.from = nodefrom;
e.to = nodeto;
e.weight = weight;
g[nodefrom].insert(std::make_pair(weight,e));
e.to = nodefrom;
e.from = nodeto;
g[nodeto].insert(std::make_pair(weight,e));
pq.insert(e);
}
out("size of g %d\n",g.size());
printf("Case %d:\n", ++ord);
print_graph(g);
float totpath = MST(g, pq);
printf ("Tot=%f\n", totpath);
printf("\n");
}
return 0;
}
Node* New_Node(int x) {
MST(foo->ch, 0), foo->len = x;
return foo++;
}
inline void solve(void) {
Input();
Dfs(1);
MST();
}
void
main(int argc, char *argv[])
{
int nVertex;
int nEdge;
Vertices * graph;
struct rusage * rUBuf1;
struct rusage * rUBuf2;
nVertex = DEFAULT_N_VERTEX;
nEdge = DEFAULT_N_EDGE;
if(argc > 1)
{
nVertex = atoi(argv[1]);
if(argc > 2)
{
nEdge = atoi(argv[2]);
if(argc > 3)
{
srandom(atoi(argv[3]));
}
}
}
rUBuf1 = (struct rusage *)malloc(sizeof(struct rusage));
assert(rUBuf1 != NULL);
rUBuf2 = (struct rusage *)malloc(sizeof(struct rusage));
assert(rUBuf1 != NULL);
if(debug)
{
printf("Generating a connected graph ... ");
}
graph = GenGraph(nVertex, nEdge);
if(debug)
{
printf("done\nFinding the mininmum spanning tree ... ");
}
getrusage(RUSAGE_SELF, rUBuf1);
graph = MST(graph);
getrusage(RUSAGE_SELF, rUBuf2);
if(debug)
{
printf("done\nThe graph:\n");
PrintGraph(graph);
printf("The minimum spanning tree:\n");
PrintMST(graph);
}
if(debug)
{
printf("Time spent in finding the mininum spanning tree:\n");
}
PrintRUsage(rUBuf1, rUBuf2);
#ifdef PLUS_STATS
PrintDerefStats(stderr);
PrintHeapSize(stderr);
#endif /* PLUS_STATS */
exit(0);
}
