10603 - Fill(BFS)

最新推荐文章于 2024-05-14 12:57:11 发布

原创最新推荐文章于 2024-05-14 12:57:11 发布 · 966 阅读

0 ·

CC 4.0 BY-SA版权

UVA 同时被 3 个专栏收录

332 篇文章

订阅专栏

暴力求解

45 篇文章

订阅专栏

暴力-隐式图搜索

7 篇文章

订阅专栏

本文探讨了如何解决倒水问题，即通过三个无刻度的杯子，将其中一个杯子装满水并根据需求获取特定水量的过程。通过隐式搜索图问题的视角，使用哈希表判重并实现最小倒水量的计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：10603 - Fill

题目大意：倒水问题。给出三个杯子，杯子都有固定容量但是没有刻度，并且第一二个杯子是空的，第三个是满的。然后给出想要的水量，问最少要倒多少的水才能得到这个水量，如果不能得到的话，最接近这个水量且小于这个水量的是多少，同样为了得到这个新的水量要的最少的倒出的水。

解题思路：这是隐式搜索图问题，把倒水后得到的状态作为图来遍历，并且开一个二维的数组来保存水量的状态（前两个确定了，第三杯的水量也是确定的），用来判重，然后还要开一个一维的数组来保存这个状态倒出的水量。杯子是空的就不能倒水，用来接水的杯子是满的就不能进行倒水动作。枚举倒水情况，用两个for循环完成。这题说是可以用哈希判重，但是构造完美的哈希函数是个问题，而且这题数据量不大，最多201*201种可能。

再次注意到数组开不够大的问题，出现一些奇奇怪怪的问题，找了好久才找到。

代码：

#include <cstdio>
#include <cstring>
#include <map>

using namespace std;

const int maxn = 1e7;
const int INF = 0x7f7f7f7f;
const int M = 3;

map<int, int> vis;
int q[maxn][M];
int c[M];
int L[maxn];
int d;
int Min, MinL;
bool flag;

bool cmp (int k) {

	for (int i = 0; i < M; i++)
		if (q[k][i] == d) {
		
			Min = d;
			if (!flag)
				MinL = L[k];
			if (flag && MinL > L[k])
				MinL = L[k];
			return true;
		}

	if (!flag) {

		int tmp = -1;
		for (int i = 0; i < M; i++)
			if (q[k][i] < d && tmp < q[k][i])
				 tmp = q[k][i];

		if (Min < tmp) {
			Min = tmp;
			MinL = L[k];
		} else if (Min == tmp && MinL > L[k]) 
			MinL = L[k];
	}
	return false;
}

int hash (int k) {

	int ans = 0;
	for (int i = 0; i < M; i++)
		ans = ans * 1000 + q[k][i];
	return ans;
}

void bfs () {

	int front, rear;
	int tmp;
	front = 0;
	rear = 1;
	MinL = INF;
	Min = -1;
	flag = 0;
	vis.clear();
	while (front < rear) {

		if (cmp(front)) {
			front++;
			flag = 1;
			continue;
		}									
		for (int i = 0; i < M; i++) {

			if (!q[front][i])
				continue;
			for (int j = 0; j < M; j++) {
				
				if (i == j)
					continue;
				if (q[front][j] == c[j])
					continue;

				tmp = q[front][j] + q[front][i];
				memcpy (q[rear], q[front], 3 * sizeof (int));

				if (tmp > c[j]) {
					q[rear][j] = c[j];
					q[rear][i] = tmp - c[j];
				} else {
					q[rear][j] = tmp;
					q[rear][i] = 0;
				}

				L[rear] = L[front] + q[front][i] - q[rear][i];	
				tmp = hash (rear);
				if (!vis[tmp]) {
					vis[tmp] = 1;
					rear++;
				}
			}
		}
		front++;
	}
}

int main () {

	int t;
	scanf ("%d", &t);
	while (t--) {

		scanf ("%d%d%d%d", &c[0], &c[1], &c[2], &d);
		q[0][0] = q[0][1] = 0;
		q[0][2] = c[2];
		L[0] = 0;
		bfs();
		printf ("%d %d\n", MinL, Min);
//		printf ("%d %d %d %d\n", q[1][0], q[1][1], q[1][2], L[1]);
	}
	return 0;
}