CODE:

#include "DxLib.h"
#include "dijkstra.h"

char Key[256];

const int MAP_WIDTH=32;
const int MAP_HEIGHT=24;

const int MOVE_NONE=0;
const int MOVE_LEFT=1;
const int MOVE_RIGHT=2;
const int MOVE_UP=3;
const int MOVE_DOWN=4;
const int move_x[5]={0,-1,1,0,0};
const int move_y[5]={0,0,0,-1,1};

int get_did(int x,int y) {
	return y*MAP_WIDTH+x;
}

int do_dijkstra(int sx,int sy,int dx,int dy,
		char map[MAP_HEIGHT][MAP_WIDTH],int& move_max,int move[]) {
	//探索の初期化 
	dijkstra_init();
	//探索用マップの作成 
	for(int i=1;i0 && click_right==0 &&
					(y!=move_target_y || x!=move_target_x))map[y][x]=0;
				else if(click_right>0 && click_left==0)map[y][x]=1;
			}
		} else if(click_left==1) {
			//移動を指示 
			int x=mouse_x/20,y=mouse_y/20;
			if(0=0) {
					moving_pos=(now_move==MOVE_NONE?0:-1);
					move[move_max++]=MOVE_NONE;
					move_target_x=x;move_target_y=y;
					if(now_move==MOVE_NONE) {
						now_move=move[0];
						move_count=0;
					}
				}
			}
		}
		for(int i=0;i=0) {
					moving_pos=0;
					move[move_max++]=MOVE_NONE;
					now_move=move[0];
					move_count=0;
				} else now_move=MOVE_NONE;
			}
		}
		//移動の実行 
		if(now_move!=MOVE_NONE) {
			move_count+=move_speed_list[move_speed];
			if(move_count>=20) {
				px+=move_x[now_move];
				py+=move_y[now_move];
				now_move=move[++moving_pos];
				move_count=0;
			}
			xoffset=move_x[now_move]*move_count;
			yoffset=move_y[now_move]*move_count;
		} else xoffset=yoffset=0;

		//マップを描画 
		for(int i=1;i
#include 
#include "dijkstra.h"

typedef struct {
	int from,to;
	int cost;
} dijkstra_edge_t;

typedef struct {
	int node;
	int from;
	int cost;
} dijkstra_node_t;

int dijkstra_edge_num;
dijkstra_edge_t dijkstra_edge[DIJKSTRA_MAX_EDGE];
int dijkstra_node_edge[DIJKSTRA_MAX_NODE][2];
int dijkstra_queue_num;
dijkstra_node_t dijkstra_queue[DIJKSTRA_MAX_EDGE+1];
int dijkstra_cost[DIJKSTRA_MAX_NODE];
int dijkstra_from[DIJKSTRA_MAX_NODE];
char dijkstra_visited[DIJKSTRA_MAX_NODE];
int dijkstra_route_num;
int dijkstra_route[DIJKSTRA_MAX_NODE];

int dijkstra_comp(const void* x,const void* y) {
	const dijkstra_edge_t* a=(const dijkstra_edge_t*)x;
	const dijkstra_edge_t* b=(const dijkstra_edge_t*)y;
	if((a->from)>(b->from))return 1;
	if((a->from)from))return -1;
	if((a->to)>(b->to))return 1;
	if((a->to)to))return -1;
	return 0;
}

void dijkstra_queue_adjust(int pos) {
	int min=pos;
	if(pos*2+1dijkstra_queue[pos*2+1].cost)
			min=pos*2+1;
	if(pos*2+2dijkstra_queue[pos*2+2].cost)
			min=pos*2+2;
	if(min!=pos) {
		dijkstra_node_t temp;
		temp=dijkstra_queue[min];
		dijkstra_queue[min]=dijkstra_queue[pos];
		dijkstra_queue[pos]=temp;
		dijkstra_queue_adjust(min);
	} else if(pos>0)dijkstra_queue_adjust((pos-1)/2);
}

void dijkstra_queue_push(int node,int cost,int from) {
	dijkstra_node_t topush;
	topush.node=node;topush.cost=cost;topush.from=from;
	dijkstra_queue[dijkstra_queue_num++]=topush;
	dijkstra_queue_adjust(dijkstra_queue_num-1);
}

dijkstra_node_t dijkstra_queue_pop(void) {
	dijkstra_node_t result=dijkstra_queue[0];
	if(dijkstra_queue_num>0) {
		dijkstra_queue[0]=dijkstra_queue[--dijkstra_queue_num];
		dijkstra_queue_adjust(0);
	}
	return result;
}

void dijkstra_init(void) {
	dijkstra_edge_num=0;
}

void dijkstra_addedge(int from,int to,int cost) {
	dijkstra_edge[dijkstra_edge_num].from=from;
	dijkstra_edge[dijkstra_edge_num].to=to;
	dijkstra_edge[dijkstra_edge_num].cost=cost;
	dijkstra_edge_num++;
}

void dijkstra_setup(void) {
	int i;
	int prev;
	qsort(dijkstra_edge,dijkstra_edge_num,
		sizeof(dijkstra_edge_t),dijkstra_comp);
	prev=0;
	memset(dijkstra_node_edge,0,sizeof(dijkstra_node_edge));
	dijkstra_node_edge[0][0]=0;
	for(i=0;i0) {
		dijkstra_node_t nownode=dijkstra_queue_pop();
		if(!dijkstra_visited[nownode.node]) {
			dijkstra_visited[nownode.node]=1;
			dijkstra_cost[nownode.node]=nownode.cost;
			dijkstra_from[nownode.node]=nownode.from;
			for(i=dijkstra_node_edge[nownode.node][0];
					inownode.cost+dijkstra_edge[i].cost)) {
					dijkstra_queue_push(
						dijkstra_edge[i].to,
						nownode.cost+dijkstra_edge[i].cost,
						nownode.node
					);
					dijkstra_cost[dijkstra_edge[i].to]=nownode.cost+dijkstra_edge[i].cost;
				}
			}
		}
	}
	if(dijkstra_cost[to]>=0) {
		dijkstra_route_num=0;
		for(now=to,i=DIJKSTRA_MAX_NODE-1;now!=from && i>=0;i--) {
			dijkstra_route[i]=now;
			now=dijkstra_from[now];
			dijkstra_route_num++;
		}
		dijkstra_route[i]=from;
		dijkstra_route_num++;
		offset=i;
		for(i=0;i<dijkstra_route_num;i++) {
			dijkstra_route[i]=dijkstra_route[i+offset];
		}
	} else {
		dijkstra_route_num=0;
	}
	return dijkstra_cost[to];
}