Exemplo n.º 1
0
// 寻找迷宫路径函数,如果存在出路,则把出路打印出来
void search_maze(int **maze, int **mark, TCellPtr pstack, int nrow, int ncol)
{
	int move[4][2] ={{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
	int top = 1;            // 路径堆栈的栈顶指针
	int found = 0;          // 标记是否找到迷宫出路,found=1表示找到出路
	int orientation = 0;    // orientation存放当前元素正遍历的方位,0为右, 1为下, 2为左, 3为上
	int next_row, next_col; // next_row, next_col分别存放当前元素的下一个元素的行列值
	TCell curcell;          // 当前迷宫单元

	// 将迷宫入口单元压入栈顶(注意迷宫外围增设了一层“外墙”,所以入口坐标为(1,1))
	pstack[0].row = 1;      
	pstack[0].col = 1;
	pstack[0].dir = 0;

	mark[1][1] = 1;   // 对迷宫入口元素进行标记,表明该单元已经走过

	while(top >= 0 && !found){      // 如果栈非空(没有退回到入口单元),并且没有找到迷宫出口,则持续寻找路径
		curcell = pstack[top--];    // 将栈顶元素出栈
		orientation  = curcell.dir; // 取栈顶元素的方向值为当前方向
		// 以curcell的当前方向为起点,顺时针遍历邻居单元
		while(orientation < 4 && !found){ //当4个方向没有遍历完,并且没有找到迷宫出口			
			next_row = curcell.row + move[orientation][0];  // 计算当前方向的邻居单元的行号
			next_col = curcell.col + move[orientation][1];  // 计算当前方向的邻居单元的列号

			if(next_row == nrow - 2 && next_col == ncol - 2){  
				found = 1;		//如果邻居单元恰好为迷宫出口,将found标志置为1
			}
			else if(!maze[next_row][next_col] && !mark[next_row][next_col]) { 
				// 如果邻居单元可达,并且未被访问过
				mark[next_row][next_col] = 1;           // 将该单元标记为已访问
				pstack[top].dir = ++orientation;        // 当前元素的下一个方向赋值给当前元素

				top++;	                        //将此元素放入栈顶	
				pstack[top].row = next_row;					
				pstack[top].col = next_col;
				pstack[top].dir = 0;

				curcell.row = next_row;
				curcell.col = next_col;
				orientation = 0;                        //方向控制dir清零
				printf("%d  %d\n", next_row, next_col);
			}
			else
				orientation++;
		}// while(dir < 4 && !found)
	}//while(top > -1 && !found)

	//如果找到迷宫出路,则调用地图输出函数;否则给出提示告诉用户该迷宫没有出路
	if(found){	
		show_route(maze, pstack, nrow, ncol, top);
	}
	else{ 
		printf("\n 该迷宫没有出路!\n");
	}
}
Exemplo n.º 2
0
bool VRP::verify_routes(const char *message)
{
    ///
    /// This debugging function will manually calculate the objective function of the current 
    /// solution and the route values, etc., and compare with the claimed 
    /// value.  Returns false if any inconsistencies are found and prints 
    /// the message.  Returns true with no output otherwise. 
    ///

    int i, n, cnt;
    double len=0;
    double rlen=0;
    double tot_len=0;
    int next_node;
    int current_node, current_route, route_start, flag, current_start, current_end;
    int total_load = 0;
    int current_load = 0;
    int num_in_route=0;
    int counted_routes=0;


    // First check the pred/next arrays for consistency
    current_node=VRPH_DEPOT;
    next_node=VRPH_ABS(this->next_array[current_node]);
    while(next_node!=VRPH_DEPOT)
    {    
        if(VRPH_ABS(this->pred_array[next_node])!=current_node)
        {
            fprintf(stderr,"%d->%d??\nNext: %d->%d\nPred:%d->%d",current_node,next_node,
                current_node,this->next_array[current_node],next_node,this->pred_array[next_node]);
            
            report_error("%s: Next/pred inconsistency\n",__FUNCTION__);
        }
        current_node=next_node;
        next_node=VRPH_ABS(this->next_array[current_node]);
    }

    if(VRPH_ABS(this->pred_array[next_node])!=current_node)
    {
        fprintf(stderr,"%d->%d??\nNext: %d->%d\nPred:%d->%d",current_node,next_node,
            current_node,this->next_array[current_node],next_node,this->pred_array[next_node]);

        report_error("%s: Next/pred inconsistency\n",__FUNCTION__);
    }

    n=num_nodes;
    // Only consider the nodes in the solution!

    flag=0;    
    i = 1;
    cnt = 0;
    route_start = -next_array[VRPH_DEPOT];
    if(route_start < 0)
    {
        fprintf(stderr,"next[VRPH_DEPOT] is incorrect\n");
        report_error(message,__FUNCTION__);

    }

    current_node = route_start;
    current_route = route_num[current_node];    
    current_start = route[current_route].start;
    current_end = route[current_route].end;
    counted_routes++;

    if(route_start != current_start)
    {
        fprintf(stderr,"Error in initial route start:  %d != %d\n",route_start, current_start);
        report_error(message,__FUNCTION__);
    }
        
    

    total_load+=nodes[current_node].demand;
    current_load+=nodes[current_node].demand;
    len+=d[VRPH_DEPOT][current_node];
    rlen+=d[VRPH_DEPOT][current_node];
    if(current_node!= dummy_index)
        num_in_route++;

    while(route_start != 0 && i<num_nodes+1)
    {
        // When we finally get a route beginning at 0, this is the last route 
        // and there is no next route, so break out

        if(next_array[current_node]==current_node)
        {
            // We've entered a loop
            fprintf(stderr,"Self loop found in next array(%d)\n",current_node);
            report_error("%s: Self loop!\n",__FUNCTION__);
        }

        if(next_array[current_node]==VRPH_DEPOT)
        {
            // We're at the end of the Solution!
            len+=d[current_node][VRPH_DEPOT];
            rlen+=d[current_node][VRPH_DEPOT];
            current_route=route_num[current_node];
            tot_len+=rlen;
            if(num_in_route != route[current_route].num_customers)
            {
                fprintf(stderr,"Customer count error!!\nCounted(%d)!=Claimed(%d) in final route %d\n",num_in_route,
                    route[current_route].num_customers,current_route);
                show_route(current_route);
                report_error(message);
            }

            // Now check the # of routes
            if(counted_routes != total_number_of_routes)
            {
                // error in # of routes
                fprintf(stderr, "Incorrect # of routes recorded %d!=%d\n",counted_routes, 
                    total_number_of_routes);
                report_error(message);

            }
            if(VRPH_ABS(len-total_route_length)<.01 && flag==0 )
            {
                // everything looks good
                return true;
            }
            else
            {
                if(VRPH_ABS(len-total_route_length)>=.01)
                {
                    fprintf(stderr,"Objective function error: calculated(%f)!=claimed(%f)\n",len,
                        total_route_length);
                    report_error(message);
                }

                
                report_error(message);

            }

        }

        if(next_array[current_node]>0)
        {
            // Next node is somewhere in the middle of a route

            next_node = next_array[current_node];
            // Make sure current_node and next_node have the same route #
            if(route_num[current_node]!=route_num[next_node])
            {
                fprintf(stderr,"Route # error for %d and %d: %d!=%d\n",current_node, next_node,
                    route_num[current_node],route_num[next_node]);
                
                report_error(message);    
            }
            len+=d[current_node][next_node];
            rlen+=d[current_node][next_node];


            current_node=next_node;

            if(current_node!= dummy_index)
                num_in_route++;

            total_load+=nodes[current_node].demand;
            current_load+=nodes[current_node].demand;
            cnt++;
        }
        else
        {
            // We must have a non-positive "next" node indicating the beginning of a new route

            len+=d[current_node][VRPH_DEPOT];

            rlen+=d[current_node][VRPH_DEPOT];
            tot_len+=rlen;
            current_route=route_num[current_node];
            current_end = route[current_route].end;

            if(num_in_route != route[current_route].num_customers)
            {
                fprintf(stderr,"%d (calculated) != %d (claimed) in route %d\n",num_in_route,
                    route[current_route].num_customers,current_route);
                show_route(current_route);
                
                // Report this now..
                report_error(message);
            }

            if(current_node != current_end)
            {
                fprintf(stderr,"Error in route ends: %d!=%d\n",current_node, current_end);
                report_error(message);
            }
            if(VRPH_ABS(rlen-route[current_route].length)>.1)
            {
                fprintf(stderr,"Route Lengths:  Calculated(%f)!=Claimed(%f)\n",rlen,route[current_route].length);

                int ii=route[current_route].start;
                int jj;
                fprintf(stderr,"0->%d = %f[%f]\n",ii, d[VRPH_DEPOT][ii], nodes[ii].service_time);
                while(ii != 0)
                {
                    jj=VRPH_MAX(VRPH_DEPOT,next_array[ii]);
                    fprintf(stderr,"%d->%d = %f[%f]\n",ii,jj,d[ii][jj], nodes[jj].service_time);
                    ii=jj;

                }

                report_error(message);
            }

            

            if(current_load != route[current_route].load)
            {
                fprintf(stderr,"Route Loads:  %d!=%d\n",current_load, route[current_route].load);
                report_error(message);
            }

            i++;
            route_start = - (next_array[current_node]);    
            current_route = route_num[route_start];
            current_start = route[current_route].start;
            current_end = route[current_route].end;
            counted_routes++;

            if(route_start != current_start)
            {
                fprintf(stderr,"Route %d:  %d != %d\n",current_route, route_start, current_start);
                report_error(message);
            }

            current_node = route_start;
            total_load+=nodes[current_node].demand;
            // reset current_load to 0
            current_load=nodes[current_node].demand;
            //len+=nodes[current_node].depot_distance;
            len+=d[VRPH_DEPOT][current_node];
            // reset rlen to 0
            //rlen=nodes[current_node].depot_distance;
            rlen=d[VRPH_DEPOT][current_node];
            if(current_node!= dummy_index)
                num_in_route=1;
            else
                num_in_route=0;
            cnt++;
        }
    }

    return true;
}    
Exemplo n.º 3
0
void route_command(const char *arg, struct session *ses)
{
    char a[BUFFER_SIZE], b[BUFFER_SIZE], way[BUFFER_SIZE], dist[BUFFER_SIZE], cond[BUFFER_SIZE];
    int j, d;

    arg=get_arg(arg, a, 0, ses);
    arg=get_arg(arg, b, 0, ses);
    arg=get_arg_in_braces(arg, way, 0);
    arg=get_arg(arg, dist, 0, ses);
    arg=get_arg_in_braces(arg, cond, 1);
    if (!*a)
    {
        tintin_printf(ses, "#THESE ROUTES HAVE BEEN DEFINED:");
        for (int i=0;i<MAX_LOCATIONS;i++)
            for (struct routenode *r=ses->routes[i];r;r=r->next)
                show_route(ses, i, r);
        return;
    }
    if (!*way)
    {
        bool first=true;
        if (!*b)
            strcpy(b, "*");
        for (int i=0;i<MAX_LOCATIONS;i++)
            if (ses->locations[i]&&match(a, ses->locations[i]))
                for (struct routenode *r=ses->routes[i];r;r=r->next)
                    if (ses->locations[i]&&
                          match(b, ses->locations[r->dest]))
                    {
                        if (first)
                        {
                            tintin_printf(ses, "#THESE ROUTES HAVE BEEN DEFINED:");
                            first=false;
                        }
                        show_route(ses, i, r);
                    }
        if (first)
            tintin_printf(ses, "#THAT ROUTE (%s) IS NOT DEFINED.", b);
        return;
    }
    int i;
    for (i=0;i<MAX_LOCATIONS;i++)
        if (ses->locations[i]&&!strcmp(ses->locations[i], a))
            goto found_i;
    if (i==MAX_LOCATIONS)
    {
        for (i=0;i<MAX_LOCATIONS;i++)
            if (!ses->locations[i])
            {
                ses->locations[i]=mystrdup(a);
                goto found_i;
            }
        tintin_eprintf(ses, "#TOO MANY LOCATIONS!");
        return;
    }
found_i:
    for (j=0;j<MAX_LOCATIONS;j++)
        if (ses->locations[j]&&!strcmp(ses->locations[j], b))
            goto found_j;
    if (j==MAX_LOCATIONS)
    {
        for (j=0;j<MAX_LOCATIONS;j++)
            if (!ses->locations[j])
            {
                ses->locations[j]=mystrdup(b);
                goto found_j;
            }
        tintin_eprintf(ses, "#TOO MANY LOCATIONS!");
        kill_unused_locations(ses);
        return;
    }
found_j:
    if (*dist)
    {
        char *err;
        d=strtol(dist, &err, 0);
        if (*err)
        {
            tintin_eprintf(ses, "#Hey! Route length has to be a number! Got {%s}.", arg);
            kill_unused_locations(ses);
            return;
        }
        if ((d<0)&&(ses->mesvar[MSG_ROUTE]||ses->mesvar[MSG_ERROR]))
            tintin_eprintf(ses, "#Error: distance cannot be negative!");
    }
    else
        d=DEFAULT_ROUTE_DISTANCE;
    addroute(ses, i, j, way, d, cond);
    if (ses->mesvar[MSG_ROUTE])
    {
        if (*cond)
            tintin_printf(ses, "#Ok. Way from {%s} to {%s} is now set to {%s} (distance=%i) condition:{%s}",
                ses->locations[i],
                ses->locations[j],
                way,
                d,
                cond);
        else
            tintin_printf(ses, "#Ok. Way from {%s} to {%s} is now set to {%s} (distance=%i)",
                ses->locations[i],
                ses->locations[j],
                way,
                d);
    }
    routnum++;
}
Exemplo n.º 4
0
static int route(int fd,char *s)
{
	char *nextargs = NULL, *arg;
	struct vder_route *ro;
	struct vder_iface *selected = NULL;
	struct in_addr temp_address, temp_netmask, temp_gateway;
	int metric = 1;
	enum command_action_enum action = -1;

	arg = strtok_r(s, " ", &nextargs);
	if(!arg) {
		/* No arguments */
		ro = Router.routing_table;
		while(ro) {
			show_route(fd, ro);
			ro = ro->next;
		}
		return 0;
	}

	if ((!arg) || (strlen(arg) != 3) || ((strncmp(arg, "add", 3) != 0) && (strncmp(arg, "del", 3) != 0))) {
		printoutc(fd, "Invalid action \"%s\".", arg);
		return EINVAL;
	}
	if (strncmp(arg, "del", 3) == 0)
		action = ACTION_DELETE;
	else
		action = ACTION_ADD;

	arg = strtok_r(NULL, " ", &nextargs);
	if (!arg) {
		not_understood(fd, "");
		return EINVAL;
	}
	if (match_input("default", arg)) {
		if (action == ACTION_ADD)
			action = ACTION_ADD_DEFAULT;
		if (action == ACTION_DELETE) {
			if (vder_route_del(0, 0, 1))
				return errno;
			else
				return 0;
		}
		arg = strtok_r(NULL, " ", &nextargs);
	}

	if (!inet_aton(arg, &temp_address) || !is_unicast(temp_address.s_addr)) {
		printoutc(fd, "Invalid address \"%s\"", arg);
		return EINVAL;
	}

	if (action == ACTION_ADD_DEFAULT) {
		if (vder_route_add(0, 0, temp_address.s_addr, 1, NULL))
			return errno;
		else
			return 0;
	}

	arg = strtok_r(NULL, " ", &nextargs);
	if (!arg) {
		printoutc(fd, "Error: parameter 'netmask' required.");
		return EINVAL;
	}

	if (!inet_aton(arg, &temp_netmask) || !is_netmask(temp_netmask.s_addr)) {
		printoutc(fd, "Invalid netmask \"%s\"", arg);
		return EINVAL;
	}

	arg = strtok_r(NULL, " ", &nextargs);
	while(arg) {
		if (match_input("via", arg)) {
			arg = strtok_r(NULL, " ", &nextargs);
			selected = select_interface(arg);
			if (!selected)
				return EINVAL;
		} else if (match_input("gw", arg)) {
			arg = strtok_r(NULL, " ", &nextargs);
			if (!inet_aton(arg, &temp_gateway) || !is_unicast(temp_gateway.s_addr)) {
				printoutc(fd, "Invalid gateway \"%s\"", arg);
				return EINVAL;
			}
		} else if (match_input("metric", arg)) {
			arg = strtok_r(NULL, " ", &nextargs);
			metric = atoi(arg);
			if (metric < 1) {
				printoutc(fd, "Invalid metric \"%s\"", arg);
				return EINVAL;
			}
		} else {
			return EINVAL;
		}
		arg = strtok_r(NULL, " ", &nextargs);
	}

	if ((action == ACTION_DELETE) &&
		   (vder_route_del(temp_address.s_addr, temp_netmask.s_addr, metric))) {
			return errno;
	} else if ((action == ACTION_ADD) &&
		   (vder_route_add(temp_address.s_addr, temp_netmask.s_addr, temp_gateway.s_addr, metric, selected))) {
		return errno;
	}
	return 0;
}