[NOIP2017]棋盘

题目描述

有一个m \times mm×m的棋盘，棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在要从棋盘的最左上角走到棋盘的最右下角。

任何一个时刻，你所站在的位置必须是有颜色的（不能是无色的）， 你只能向上、 下、左、 右四个方向前进。当你从一个格子走向另一个格子时，如果两个格子的颜色相同，那你不需要花费金币；如果不同，则你需要花费 11个金币。

另外， 你可以花费 22 个金币施展魔法让下一个无色格子暂时变为你指定的颜色。但这个魔法不能连续使用， 而且这个魔法的持续时间很短，也就是说，如果你使用了这个魔法，走到了这个暂时有颜色的格子上，你就不能继续使用魔法； 只有当你离开这个位置，走到一个本来就有颜色的格子上的时候，你才能继续使用这个魔法，而当你离开了这个位置（施展魔法使得变为有颜色的格子）时，这个格子恢复为无色。

现在你要从棋盘的最左上角，走到棋盘的最右下角，求花费的最少金币是多少？

输入输出格式

输入格式：

 

第一行包含两个正整数m, nm,n，以一个空格分开，分别代表棋盘的大小，棋盘上有颜色的格子的数量。

接下来的nn行，每行三个正整数x, y, cx,y,c， 分别表示坐标为(x,y)(x,y)的格子有颜色cc。

其中c=1c=1 代表黄色，c=0c=0 代表红色。 相邻两个数之间用一个空格隔开。 棋盘左上角的坐标为(1, 1)(1,1)，右下角的坐标为( m, m)(m,m)。

棋盘上其余的格子都是无色。保证棋盘的左上角，也就是(1, 1)(1,1) 一定是有颜色的。

 

输出格式：

 

一个整数，表示花费的金币的最小值，如果无法到达，输出-1−1。

 

输入输出样例

输入样例#1： 

5 7
1 1 0
1 2 0
2 2 1
3 3 1
3 4 0
4 4 1
5 5 0

输出样例#1： 

8

输入样例#2： 

5 5
1 1 0
1 2 0
2 2 1
3 3 1
5 5 0

输出样例#2： 

-1

 

可惜当时没有进复赛，如果进了一等奖就是必拿的

这一道题我用了广度优先BFS来做，注意题目说的改变格子颜色的法术不能连续使用

注释放入代码

#include 
#include 
#include 

using namespace std ;

const int N = 110 ;
int n , map[N][N] ;

struct node {
	int x , y , s , now ; //如果当前格子有颜色，那么now=-1，否则now==改成的颜色  ， 坐标（x,y) 费用s 
	inline bool operator < ( const node &k ) const {
		return  k.s < s  ;
	}
} ;
priority_queue < node > q ;
int dis[N][N] ; //dis记录最小花费 

const int dx[4] = { 0 , 0 , 1 , -1 } ;
const int dy[4] = { 1 , -1 , 0 , 0 } ;

int main() {
	int t , x , y , c , s , now ; cin >> n >> t ;
	memset ( map , -1 , sizeof(map) ) ;
	while ( t-- ) {
		cin >> x >> y >> c ;
		map[x][y] = c ;
	}
	memset ( dis , 63 , sizeof(dis) ) ; dis[1][1] = 0 ;
	q.push( (node){ 1 , 1 , 0 , -1 } ) ;
	while ( !q.empty() ) {
		x = q.top().x , y = q.top().y , 
		s = q.top().s , now = q.top().now ; //先把这四个记录下来 
		q.pop() ; if ( x == n && y == n ) { cout << s << endl ; return 0 ; } //到终点就直接输出 
		if ( s > dis[x][y] ) continue ; //剪枝 
		for ( int i = 0 ; i < 4 ; i ++ ) {
			int xx = x + dx[i] ; //新的坐标 
			int yy = y + dy[i] ;
			if ( !( 1<=xx && xx<=n && 1<=yy && yy<=n ) ) continue ; //如果超出边界 
			if ( map[xx][yy] == -1 ) { //如果这个点是空格 
				if( now != -1 ) continue ; //如果我是从空格来的，那么就不能到这个格子 
				for ( int j = 0 ; j <= 1 ; j ++ ) { //是把这个格子变成1好还是0好 
					int ss = s + 2 ; //花费+2 
					ss += ( j == map[x][y] ? 0 : 1 ) ; //判断是否要花费1 
					if ( dis[xx][yy] > ss ) { //如果这个是更优解，就往下搜 
						dis[xx][yy] = ss ;
						q.push( (node){ xx , yy , ss , j } ) ;
					}
				}
			}
			else {
				int ss ; //如果不是空格 
				if ( now == -1 ) ss = s + ( map[xx][yy] == map[x][y] ? 0 : 1 ) ; //我从非空格的格子来 
				else ss = s + ( map[xx][yy] == now ? 0 : 1 ) ; //我从空格的格子来 
				if ( dis[xx][yy] > ss ) { //更新 
					dis[xx][yy] = ss ;
					q.push( (node){ xx , yy , ss , -1 } ) ;
				}
			}
		}
	}
	cout << "-1" << endl ; //输出 
	return 0 ;
}