CCF——最优配餐

问题描述

栋栋最近开了一家餐饮连锁店，提供外卖服务。随着连锁店越来越多，怎么合理的给客户送餐成为了一个急需解决的问题。

　　栋栋的连锁店所在的区域可以看成是一个n×n的方格图（如下图所示），方格的格点上的位置上可能包含栋栋的分店（绿色标注）或者客户（蓝色标注），有一些格点是不能经过的（红色标注）。

　　方格图中的线表示可以行走的道路，相邻两个格点的距离为1。栋栋要送餐必须走可以行走的道路，而且不能经过红色标注的点。

　　


送餐的主要成本体现在路上所花的时间，每一份餐每走一个单位的距离需要花费1块钱。每个客户的需求都可以由栋栋的任意分店配送，每个分店没有配送总量的限制。

　　现在你得到了栋栋的客户的需求，请问在最优的送餐方式下，送这些餐需要花费多大的成本。

输入格式

输入的第一行包含四个整数n, m, k, d，分别表示方格图的大小、栋栋的分店数量、客户的数量，以及不能经过的点的数量。

　　接下来m行，每行两个整数xi, yi，表示栋栋的一个分店在方格图中的横坐标和纵坐标。

　　接下来k行，每行三个整数xi, yi, ci，分别表示每个客户在方格图中的横坐标、纵坐标和订餐的量。（注意，可能有多个客户在方格图中的同一个位置）

　　接下来d行，每行两个整数，分别表示每个不能经过的点的横坐标和纵坐标。

　

输出格式

输出一个整数，表示最优送餐方式下所需要花费的成本。

样例输入

10 2 3 3
1 1
8 8
1 5 1
2 3 3
6 7 2
1 2
2 2
6 8

样例输出

29

解题思路

看完这题之后，给我的第一感觉那就是采用“树”型数据结构，进行广度优先算法搜索（BFS）或者深度优先算法搜索（DFS），也可采用“图”型数据结构进行最短路径寻找。可写了写，发现这些结构相对比较复杂，加之对这些结构的理解程度尚未成熟，便看了看别人的代码，学习学习。

Code

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
int n, m, k, d;
short map[1005][1005], dir[4][2] = { { 1,0 },{ 0,1 },{ -1,0 },{ 0,-1 } };
bool within(int x, int y) {
if (x <= 0 || x > n || y <= 0 || y > n)
return false;
return true;
}
struct node {
int x, y, step;
node(int a = 0, int b = 0, int c = 0) {
x = a;
y = b;
step = c;
}
};
queue<node> q;
long long bfs() {
node n;
int t = 0;
long long sum = 0;
while (!q.empty()) {
n = q.front();
q.pop();
int i, x, y;
for (i = 0; i < 4; i++) {
x = n.x + dir[i][0];
y = n.y + dir[i][1];
if (within(x, y) && !(map[x][y] & 1)) {
map[x][y] |= 1;
if (map[x][y] & 2) {
sum += (map[x][y] >> 2)*(n.step + 1);
t++;
if (t == k)
return sum;
}
q.push(node(x, y, n.step + 1));
}
}
}
}
int main() {
while (scanf_s("%d %d %d %d", &n, &m, &k, &d) != EOF) {
int i, j, x, y;
memset(map, 0, sizeof(map));
for (i = 0; i < m; i++) {
scanf_s("%d %d", &x, &y);
map[x][y] |= 1;
q.push(node(x, y, 0));
}
for (i = 0; i < k; i++) {
scanf_s("%d %d %d", &x, &y, &j);
map[x][y] = (map[x][y] | 2) + (j << 2);
}
for (i = 0; i < d; i++) {
scanf_s("%d %d", &x, &y);
map[x][y] |= 1;
}
printf_s("%I64d\n", bfs());
}
return 0;
}

这个算法的基本思路是采用队列进行模拟四叉树来进行广度优先搜索（BFS），首先定义dir数组，且赋予一定的值，方便后面进行找节点（node）的上，下，左，右四个邻接节点，然后判断是否是无法通过点，是就出队，不要这个节点，否就进队，继续搜索，直到找到目标地点为止，最后再将总步数进行输出，就是最短路径了。