# Testing: Code

This post will be used to test code highlighting (C++).


/************************************************\
* C++ Dijkstra
* From: http://tjsct.wikidot.com/dijkstra
* To:   Test Syntax Highlighter
\************************************************/

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

#define VMAX (1001)
#define EMAX (30001)
#define INTMAX (9223372036854775807LL)

ifstream fin("dij.in");
ofstream fout("dij.out");

int visited[VMAX];
vector< pair<long long,int> > priolist; //distance list will be a heap now

struct Something
{
int nValue;
float fValue;
};

enum Colors
{
COLOR_BLACK,
COLOR_WHITE,
COLOR_RED,
COLOR_GREEN,
COLOR_BLUE,
};

int main()
{
int V,E;

fin >> V; fin >> E;

for(int i=0; i<E; i++) {
int v1,v2,tmp;
fin >> v1; fin >> v2;
fin >> tmp;
}

//the distance list is set up as usual
priolist.push_back(pair<long long, int>(0LL,1));

//pulling the minimum off is auotmatically covered by the heap
while(!priolist.empty()) {
int cur=priolist[0].second; //min resides on front
int curdist=priolist[0].first;

//pop_heap takes the head of the heap and puts it on the
//end of the vector, then we take it off.
//also we use greater to make a min heap (default heap is max)
pop_heap(priolist.begin(),priolist.end(),\
greater< pair<long long, int> >());
priolist.pop_back();

//if we hit the desired node, stop.
//also some nodes can come off the heap twice
if(cur==V){fout << curdist << endl; break;}
if(visited[cur]!=0){continue;}

visited[cur]=1;

//this is where some nodes get on the heap more than once
//we allow this because it is more expensive to find and update
//a node once it is on the heap than it is to allow the heap
//to contain more than one possible distance to a node
//first we put the desired item on the back of
//the vector for heaping
priolist.push_back(pair<long long,int>(curdist\
//then we do the heaping
push_heap(priolist.begin(),priolist.end(),\
greater< pair<long long, int> >());
}
}
}

// Member selection using actual struct variable
Something sSomething;
sSomething.nValue = 5;
sSomething.fValue = 5.23108;

// Member selection using reference to struct

// Member selection using pointer to struct
Something *psSomething = &sSomething;
(*psSomething).nValue = 5;

int *pnValue = new int; // dynamically allocate an integer
*pnValue = 7; // assign 7 to this integer
delete pnValue; // unallocate memory assigned to pnValue
pnValue = 0;

switch (eColor)
{
case COLOR_BLACK:
cout << "Black";
break;
case COLOR_WHITE:
cout << "White";
break;
case COLOR_RED:
cout << "Red";
break;
case COLOR_GREEN:
cout << "Green";
break;
case COLOR_BLUE:
cout << "Blue";
break;
default:
cout << "Unknown";
break;
}

cout << "Hello World!" << '\n';
if(true && false || 1)
cout << "true: " << true;

exit(0);
}