CCF 201409-4 最优配餐

试题编号：	201409-4
试题名称：	最优配餐
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述 　　栋栋最近开了一家餐饮连锁店，提供外卖服务。随着连锁店越来越多，怎么合理的给客户送餐成为了一个急需解决的问题。 　　栋栋的连锁店所在的区域可以看成是一个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 评测用例规模与约定 　　前30%的评测用例满足：1<=n <=20。 　　前60%的评测用例满足：1<=n<=100。 　　所有评测用例都满足：1<=n<=1000，1<=m, k, d<=n^2。可能有多个客户在同一个格点上。每个客户的订餐量不超过1000，每个客户所需要的餐都能被送到。

 看到题目，首先想的是从店家到顾客进行bfs，动手写的时候突然想到如果从店家到顾客，那每个店家都要对每个顾客算距离，而从顾客到店家只用bfs到一个店家终止就可以了，当时还暗自窃喜，没想到入了另外一个坑。

先上 顾客到店家的代码，只得了60分

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

typedef struct{
	int x;		//客户坐标x 
	int y;		//客户坐标y 
	int deep;	//距离当前坐标最近的分店的距离 
}Ke;	// 客户结构体 

int status[1005][1005]={0};		// 标注每个点的状态，是分店 1，还是客户 2，还是不能经过的点 3 默认0
int map[1005][1005]={0};		// 如果是客户，存储每个点上客户需求量
int stamp[1005][1005]={0};		// 0表示未遍历，1表示正在队列中待遍历 2表示完全遍历 

vector<Ke> vec;		// 存储所有客户,便于后边计算 

int n,m,k,d;

// 注意，不能大于n 小于1 且status不能为3     边界值 		// 此处从客户BFS找到最近的分店比较方便 
int BFS(int x,int y){
	
	int i,j;
	
	// 重置遍历状态 
	for(i=0;i<=n;i++){
		for(j=0;j<=n;j++){
			stamp[i][j]=0;
		}
	}
	//  用3将地图包围起来，判断行不行得通的时候只用判断status是不是3即可,main中已实现 
	 
	queue<Ke> que;
	Ke tmp1;		tmp1.x=x;tmp1.y=y;tmp1.deep=0;
	que.push(tmp1);
	stamp[x][y]=1;
	while(que.size()>0){
		Ke tmp = que.front();	//cout<<tmp.x<<" "<<tmp.y<<" "<<tmp.deep<<endl;
		que.pop();
		// 左 
		if(status[tmp.x-1][tmp.y]==1)return tmp.deep+1;
		if(stamp[tmp.x-1][tmp.y]==0&&status[tmp.x-1][tmp.y]!=3){
			stamp[tmp.x-1][tmp.y]=1;
			
			Ke tmpxy ;
			tmpxy.x=tmp.x-1;
			tmpxy.y=tmp.y;	tmpxy.deep = tmp.deep+1;
			que.push(tmpxy);
		}
		// 右 
		if(status[tmp.x+1][tmp.y]==1)return tmp.deep+1;
		if(stamp[tmp.x+1][tmp.y]==0&&status[tmp.x+1][tmp.y]!=3){
			stamp[tmp.x+1][tmp.y]=1;
			
			Ke tmpxy ;
			tmpxy.x=tmp.x+1;
			tmpxy.y=tmp.y;	tmpxy.deep = tmp.deep+1;
			que.push(tmpxy);
		}
		// 上 
		if(status[tmp.x][tmp.y-1]==1)return tmp.deep+1;
		if(stamp[tmp.x][tmp.y-1]==0&&status[tmp.x][tmp.y-1]!=3){
			stamp[tmp.x][tmp.y-1]=1;
			
			Ke tmpxy ;
			tmpxy.x=tmp.x;
			tmpxy.y=tmp.y-1;	tmpxy.deep = tmp.deep+1;
			que.push(tmpxy);
		}
		// 下 
		if(status[tmp.x][tmp.y+1]==1)return tmp.deep+1;
		if(stamp[tmp.x][tmp.y+1]==0&&status[tmp.x][tmp.y+1]!=3){
			stamp[tmp.x][tmp.y+1]=1;
			
			Ke tmpxy ;
			tmpxy.x=tmp.x;
			tmpxy.y=tmp.y+1;	tmpxy.deep = tmp.deep+1;
			que.push(tmpxy);
		}
		stamp[tmp.x][tmp.y]=2;	
	}
	
}

int main(){
	
	cin>>n>>m>>k>>d;
	int x,y,t;
	
	//  用3将地图包围起来，判断行不行得通的时候只用判断status是不是3即可
	for(int i=0;i<=n+1;i++){
		status[0][i]=3;		status[n+1][i]=3; 
		status[i][0]=3;		status[i][n+1]=3;
	}
	
	// 输入分店 
	for(int i=0;i<m;i++){
		cin>>x>>y;		status[x][y] = 1;
	}
	// 输入客户 
	Ke tmp;
	for(int i=0;i<k;i++){
		cin>>x>>y>>t;	status[x][y] = 2;			
		// 如果该点需求量为0，则新加客户 ,否则不新加客户 
		if(map[x][y]==0){
			tmp.x=x;tmp.y=y; 
			vec.push_back(tmp);
		} 
		map[x][y]+=t;
		
	}
	for(int i=0;i<d;i++){
		cin>>x>>y;		status[x][y] = 3;
	}
	long long result=0;
	//for(int i=0;i<n+3;i++){for(int j=0;j<n+3;j++)cout<<status[i][j]<<"  ";cout<<endl;}
	for(int i=0;i<vec.size();i++){
		
		tmp = vec[i];
		long long len = BFS(tmp.x,tmp.y);
		//cout<<tmp.x<<tmp.y<<len<<"		xxx"<<endl;;
		result+=len*map[tmp.x][tmp.y];
	}
	cout<<result<<endl;
	return 0;
}

　　做完提交超时只有60分，想不出更简单的方法，网上看了一下别人的思路，才发现从店家到顾客遍历才行。于是写了一遍从店家到顾客（依次以每个店家坐标为起始对整个图做bfs），最后也只是得了90分。后来才发现这个遍历还有个巧处，同时将分店同时加到bfs的初始队列中进行遍历，这点很妙。

代码：

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

typedef struct node{
	int x;		//客户坐标x 
	int y;		//客户坐标y 
	int deep;	//距离当前坐标最近的分店的距离 
	node(int a=0,int b=0,int c=0){
		x=a;y=b;deep=c;
	}
}Ke;	// 客户结构体 ,也可以用来保存分店坐标此时deep无意义 

short status[1005][1005]={0};		// 标注每个点的状态，是分店 1，还是客户 2，还是不能经过的点 3 默认0
int map[1005][1005]={0};		// 如果是客户，存储每个点上客户需求量
short stamp[1005][1005]={0};		// 0表示未遍历，1表示正在队列中待遍历 2表示完全遍历 
int minLen[1005][1005];			// 表示每个点距离最近的店的距离， 初始化时要弄到最大 

int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};

vector<Ke> vec;		// 存储所有客户,便于后边计算总花费 
vector<Ke> dian;	// 存储所有分店，作为遍历的起点 

int n,m,k,d;


// 注意，不能大于n 小于1 且status不能为3     边界值 		
void BFS(){
	
	int i,j;
	int keCount = 0;
	// 重置遍历状态 
	for(i=0;i<=n;i++){
		for(j=0;j<=n;j++){
			stamp[i][j]=0;
		}
	}
	//  用3将地图包围起来，判断行不行得通的时候只用判断status是不是3即可
	for(int i=0;i<=n+1;i++){
		status[0][i]=3;		status[n+1][i]=3; 
		status[i][0]=3;		status[i][n+1]=3;
	}
	
	queue<Ke> que;
	for(i=0;i<dian.size();i++){
		que.push(dian[i]);
	}
	while(que.size()>0&&keCount<=k){
		Ke tmp = que.front();	//cout<<tmp.x<<" "<<tmp.y<<" "<<tmp.deep<<endl;
		que.pop();
		int deep = tmp.deep;
		
		for(i=0;i<4;i++){
			int x = tmp.x+dir[i][0];
			int y = tmp.y+dir[i][1];
			if(stamp[x][y]==0&&status[x][y]!=3){
				stamp[x][y] = 1;
				
				minLen[x][y] = deep+1;
				que.push(Ke(x,y,deep+1));
				
				if(status[x][y]==2)keCount++;
			}
			
		}
		stamp[tmp.x][tmp.y]=2;
	}
	
}

int main(){
	
	cin>>n>>m>>k>>d;
	int x,y,t;
	Ke tmp;

	// 初始化每个点距离最近点的距离为最大值
	for(int i=0;i<=n+1;i++){
		for(int j=0;j<=n+1;j++)	minLen[i][j] = 1000000;
	}
	// 输入分店 
	for(int i=0;i<m;i++){
		cin>>x>>y;		status[x][y] = 1;
		tmp.x=x;tmp.y=y; 
		dian.push_back(tmp);
	}
	// 输入客户 
	for(int i=0;i<k;i++){
		cin>>x>>y>>t;	status[x][y] = 2;			
		// 如果该点需求量为0，则新加客户 ,否则不新加客户 
		if(map[x][y]==0){
			tmp.x=x;tmp.y=y; 
			vec.push_back(tmp);
		} 
		map[x][y]+=t;
		
	}
	for(int i=0;i<d;i++){
		cin>>x>>y;		status[x][y] = 3;
	}
	long long result=0;
	BFS();
	for(int i=0;i<vec.size();i++){
		tmp = vec[i];
		result+=minLen[tmp.x][tmp.y]*map[tmp.x][tmp.y];
	}
	cout<<result<<endl;
	return 0;
}