int floyd_warshall(int * map, int vertex_num)
{
int i,j,k;
int max_path_len=128;
int dis[vertex_num*vertex_num];
char *path[vertex_num*vertex_num];
init_dis_from_map(dis,map,vertex_num);
malloc_path(path,max_path_len,vertex_num);
init_path(path,max_path_len,vertex_num);
for(k=0; k < vertex_num; k++)
{
for(i = 0; i < vertex_num; i++)
{
for(j = 0; j < vertex_num; j++)
{
if(dis[i*vertex_num+j] > dis[i*vertex_num+k] + dis[k*vertex_num +j] )
{
dis[i*vertex_num+j] = dis[i*vertex_num+k] + dis[k*vertex_num +j];
snprintf(path[i*vertex_num +j],max_path_len,"%s,%s",path[i*vertex_num+k],path[k*vertex_num + j]);
}
}
}
}
printf("the floyd-warrshall result: \n");
print_distance(dis,vertex_num);
printf("the path result is \n");
print_path(path,vertex_num);
destroy_path(path,vertex_num);
return OK;
}
int main(int argc, char *argv[])
{
FILE *fp;
fp = fopen("brand.dat", "rt");
fscanf(fp, "%d", &max_dist);
fscanf(fp, "%d", &ntowns);
rewind(fp);
fclose(fp);
distance = malloc(ntowns * sizeof(int *));
fire_dept = malloc(ntowns * sizeof(int));
int i;
for (i = 0; i < ntowns; i += 1)
fire_dept[i] = EMPTY;
for (i = 0; i < ntowns; i += 1)
distance[i] = malloc(ntowns * sizeof(int));
read_from_file(ntowns);
print_distance(ntowns);
for (i = 0; i < ntowns; i += 1) {
fire_dept[i] = STATION;
permute(fire_dept, 0, ntowns, i + 1);
}
clean_up(ntowns);
return 0;
}
void print_routes(char node, int edges[X]) {
for (int i = 0; i < X; i++) {
char neighbor = getNodeName(i);
int distance = edges[i];
printf("%c -> %c: ", node, neighbor);
print_distance(distance);
}
}
static void
route_disp_wpt_cb(const waypoint *wpt)
{
waypoint *prev = cur_info->prev_wpt;
gbfprintf(fout, "Route Waypoint\t");
gbfprintf(fout, "%s\t", wpt->shortname);
if (prev != NULL)
{
double dist = waypt_distance_ex(prev, wpt);
cur_info->total += dist;
print_distance(cur_info->total, 0, 1, 0);
print_distance(dist, 0, 1, 0);
print_course(prev, wpt);
}
else
print_distance(0, 1, 0, 0);
gbfprintf(fout, "\r\n");
cur_info->prev_wpt = (waypoint *)wpt;
}
static void
track_disp_wpt_cb(const waypoint *wpt)
{
waypoint *prev = cur_info->prev_wpt;
time_t delta;
double dist, depth;
gbfprintf(fout, "Trackpoint\t");
print_position(wpt);
print_date_and_time(wpt->creation_time, 0);
if IS_VALID_ALT(wpt->altitude)
print_distance(wpt->altitude, 1, 0, 0);
gbfprintf(fout, "\t");
depth = WAYPT_GET(wpt, depth, unknown_alt);
if (depth != unknown_alt)
print_distance(depth, 1, 0, 1);
if (prev != NULL) {
float temp;
gbfprintf(fout, "\t");
delta = wpt->creation_time - prev->creation_time;
temp = WAYPT_GET(wpt, temperature, -999);
if (temp != -999)
print_temperature(temp);
gbfprintf(fout, "\t");
dist = waypt_distance_ex(prev, wpt);
print_distance(dist, 0, 1, 0);
print_date_and_time(delta, 1);
print_speed(&dist, &delta);
print_course(prev, wpt);
}
gbfprintf(fout, "\r\n");
cur_info->prev_wpt = (waypoint *)wpt;
}
void Dijkstra(int start_index){
bool used[SIZE];
memset(used, 0, sizeof(bool) * SIZE);
for(int i = 0;i < SIZE;i++){
if(graph[start_index][i] != MAX_DIST){
distance[i] = graph[start_index][i];
}
}
used[start_index] = true;
while(true){
// choose min index
int min_dist = MAX_DIST;
int min_index = -1;
for(int i = 0;i < SIZE;i++){
if(used[i]) continue;
if(distance[i] < min_dist){
min_index = i;
min_dist = distance[min_index];
}
}
if(min_index == -1) break; // all nodes have been used
used[min_index] = true;
#ifdef VERBOSE
printf("Closest node from %d is %d, distance %d\n", start_index + 1, min_index + 1, min_dist);
#endif
// try to loose
for(int i = 0;i < SIZE;i++){
if(distance[i] > distance[min_index] + graph[min_index][i]){
#ifdef VERBOSE
printf("Found a shorter way from %d to %d, whose distance is %d\n", min_index + 1, i + 1, distance[min_index] + graph[min_index][i]);
#endif
distance[i] = distance[min_index] + graph[min_index][i];
}
}
#ifdef VERBOSE
printf("After trying loosing with node %d:\n", min_index + 1);
print_distance();
printf("\n");
#endif
}
}
static void
route_disp_hdr_cb(const route_head *rte)
{
current_trk = (route_head *)rte;
cur_info = &route_info[route_idx];
cur_info->prev_wpt = NULL;
cur_info->total = 0;
if (rte->rte_waypt_ct <= 0) return;
if (!gtxt_flags.route_header_written) {
gtxt_flags.route_header_written = 1;
gbfprintf(fout, "\r\n\r\nHeader\t%s\r\n", headers[route_header]);
}
print_string("\r\nRoute\t%s\t", current_trk->rte_name ? current_trk->rte_name : "");
print_distance(cur_info->length, 0, 1, 0);
print_course(cur_info->first_wpt, cur_info->last_wpt);
gbfprintf(fout, "\t%d waypoints\t", cur_info->count);
print_string("%s\r\n", rte->rte_url ? rte->rte_url : "");
gbfprintf(fout, "\r\nHeader\t%s\r\n\r\n", headers[rtept_header]);
}
static void
track_disp_hdr_cb(const route_head *track)
{
cur_info = &route_info[route_idx];
cur_info->prev_wpt = NULL;
cur_info->total = 0;
current_trk = (route_head *)track;
if (track->rte_waypt_ct <= 0) return;
if (!gtxt_flags.track_header_written) {
gtxt_flags.track_header_written = 1;
gbfprintf(fout, "\r\n\r\nHeader\t%s\r\n", headers[track_header]);
}
print_string("\r\nTrack\t%s\t", current_trk->rte_name ? current_trk->rte_name : "");
print_date_and_time(cur_info->start, 0);
print_date_and_time(cur_info->time, 1);
print_distance(cur_info->length, 0, 1, 0);
print_speed(&cur_info->length, &cur_info->time);
print_string("%s", (track->rte_url != NULL) ? track->rte_url : "");
gbfprintf(fout, "\r\n\r\nHeader\t%s\r\n\r\n", headers[trkpt_header]);
}
int main(){
for(int i = 0;i < SIZE;i++){
for(int j = 0;j < SIZE;j++){
scanf("%d", &graph[i][j]);
if(graph[i][j] == -1){
graph[i][j] = MAX_DIST;
}
}
}
for(int i = 0;i < SIZE;i++){
distance[i] = MAX_DIST;
}
int start_index;
scanf("%d", &start_index);
Dijkstra(start_index - 1);
print_graph();
print_distance();
getchar();
return 0;
}
void shortest_path(int start, int cost[][NODES],
int distance[], int n, int found[]) /* 시작노드 start */
{
int i, u, w;
for(i=0; i<n; i++) /* 초기화 */
{
distance[i] = cost[start][i];
path[i] = start;
found[i] = FALSE;
}
found[start] = TRUE; /* 시작노드 방문 표시 */
distance[start] = 0;
for(i=0; i<n; i++){
print_distance();
u = choose(distance, n, found);
found[u] = TRUE;
for(w=0;w<n; w++)
if(!found[w])
if( distance[u]+cost[u][w] < distance[w] ) {
distance[w] = distance[u]+cost[u][w];
path[w] = u; /* 경유노드 저장 */
}
}
}
static void
write_waypt(const waypoint *wpt)
{
unsigned char wpt_class;
garmin_fs_p gmsd;
char *wpt_type;
char *dspl_mode;
const char *country;
double x;
int i, icon, dynamic;
char *icon_descr;
gmsd = GMSD_FIND(wpt);
i = GMSD_GET(display, 0);
if (i > GT_DISPLAY_MODE_MAX) i = 0;
dspl_mode = gt_display_mode_names[i];
wpt_class = GMSD_GET(wpt_class, 0);
if (wpt_class <= gt_waypt_class_map_line)
wpt_type = gt_waypt_class_names[wpt_class];
else
wpt_type = gt_waypt_class_names[0];
gbfprintf(fout, "Waypoint\t%s\t", (wpt->shortname) ? wpt->shortname : "");
if (wpt_class <= gt_waypt_class_airport_ndb) {
char *temp = wpt->notes;
if (temp == NULL) {
if (wpt->description && (strcmp(wpt->description, wpt->shortname) != 0))
temp = wpt->description;
else
temp = "";
}
print_string("%s\t", temp);
}
else
gbfprintf(fout, "\t");
gbfprintf(fout, "%s\t", wpt_type);
print_position(wpt);
if IS_VALID_ALT(wpt->altitude)
print_distance(wpt->altitude, 1, 0, 0);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, depth, unknown_alt);
if (x != unknown_alt)
print_distance(x, 1, 0, 1);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, proximity, unknown_alt);
if (x != unknown_alt)
print_distance(x, 0, 0, 0);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, temperature, -999);
if (x != -999)
print_temperature(x);
gbfprintf(fout, "\t%s\t", dspl_mode);
gbfprintf(fout, "Unknown\t"); /* Color is fixed: Unknown */
icon = GMSD_GET(icon, -1);
if (icon == -1) {
icon = gt_find_icon_number_from_desc(wpt->icon_descr, GDB);
}
icon_descr = gt_find_desc_from_icon_number(icon, GDB, &dynamic);
print_string("%s\t", icon_descr);
if (dynamic) xfree(icon_descr);
print_string("%s\t", GMSD_GET(facility, ""));
print_string("%s\t", GMSD_GET(city, ""));
print_string("%s\t", GMSD_GET(state, ""));
country = gt_get_icao_country(GMSD_GET(cc, ""));
print_string("%s\t", (country != NULL) ? country : "");
print_date_and_time(wpt->creation_time, 0);
print_string("%s\t", wpt->url ? wpt->url : "");
print_categories(GMSD_GET(category, 0));
gbfprintf(fout, "\r\n");
}
void main()
{
shortest_path(0, cost, distance, NODES, found);
print_path(0,3);
print_distance();
}
