图论 - 广度优先搜索 - 倒水问题

倒水问题

时间限制：10 sec

空间限制：256 MB

问题描述

邓老师有有 2 个容量分别为 n 单位、m 单位的没有刻度的杯子。初始，它们都是空的。

邓老师给了你 t 分钟时间。每一分钟，他都可以做下面 4 件事中的任意一件：

1. 用水龙头装满一个杯子。
2. 倒空一个杯子。
3. 把一个杯子里的水倒到另一个杯子里，直到一个杯子空了或者另一个杯子满了。
4. 什么都不做。

邓老师希望最后能获得 d 个单位的水，假设最后两个杯具中水量的总和为 x，那么邓老师的不满意度就为 |d-x|。

你希望邓老师尽可能地满意，于是请你计算邓老师的不满意度最小是多少。

输入格式

一行 4 个整数 n,m,t,d，分别表示两个杯具的容量、时间限制、以及邓老师的期望值。

输出格式

一行一个整数，表示邓老师最小的不满意度。

样例输入

7 25 2 16

样例输出

9

样例解释

你可以在第 1 分钟用水龙头装满任意一个杯子，并在第 2 分钟什么都不做，即可让邓老师的不满意度为 9。

可以证明不存在更优的解。

数据范围

本题共设置 16 个测试点。

对于前 1 个测试点，保证 t=1。

对于前 2 个测试点，保证 t<=2。

对于前 4 个测试点，保证 t<=4。

对于前 10 个测试点，保证 1<=n,m<=100，1<=t<=100，1<=d<=200。

对于所有的 16 个测试点，保证 1<=n,m<=2,000，1<=t<=200，1<=d<=4,000。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

思路

       本题是图的广度优先搜索的简单应用练习题。设两个杯中的水量为状态，从每个状态有六种选择向其他状态迁移：清空杯子1，清空杯子2，装满杯子1，装满杯子2，杯1的水倒入杯2，杯2的水倒入杯1。若采用暴力解法，则从 (0, 0) 开始，对每种状态枚举六种所有可能，共 t 步，则复杂度为 O(6^t)，如下图（左）所示。这样其实有很多重复计算的部分，当到达某种状态时，它如果已经通过其他方式达到过，则没有必要再从它扩展出其他状态一次了。我们可以将记录两个杯子当前水量的状态看做图中的结点，然后按照上述六种可能的操作方式扩展出其他结点，并记录第一次扩展出某结点所用的步数，然后按照广度优先建立图，(0, 0) 是起点，最多 t 步停止。例如，杯子容量分别为3和2，进行两步，得到如下图（右）。另外，可以在建立图的过程中随时记录杯中水总量和期望水量的最小差异，若差异为0，可以提前终止。

 

 

C++代码

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <utility>

using namespace std;

const int MAXN = 2000;    // 杯子的最大可能容量 

int min_t[MAXN+5][MAXN+5];    // min_t[u][v]：从两个杯子均空到达水量分别为u, v需要的最小步数，-1表示未到达 

pair<int, int> toNewState(int n, int m, int u, int v, int i)
{
    switch(i)
    {
        case 0:   // 清空杯子1 
            return make_pair(0, v); 
            break;
        case 1:   // 清空杯子2 
            return make_pair(u, 0);
            break;
        case 2:   // 装满杯子1 
            return make_pair(n, v); 
            break;
        case 3:   // 装满杯子2
            return make_pair(u, m);  
            break;
        case 4:   // 杯子1 -> 杯子2 
            return make_pair(max(0, u-m+v), min(m, u+v));
            break;
        case 5:   // 杯子2 -> 杯子1
            return make_pair(min(n, u+v), max(0, v-n+u));
            break;
    }
}

int bfs(int n, int m, int t, int d)
{
    int ans = d;
    memset(min_t, -1, sizeof(min_t)); min_t[0][0] = 0;    // 初始化min_t
    queue<pair<int, int> > q;
    q.push(make_pair(0, 0));
    while ( !q.empty() )
    {    
        pair<int, int> s = q.front(); q.pop();
        if ( min_t[s.first][s.second] >= t )    // 若已经大于t步，则结束（因为广度优先搜索是由近到远的，故队列中出现距离为t的说明后面的也都不小于t） 
            break;
        for ( int i = 0; i < 6; ++i )
        {
            pair <int, int> new_s = toNewState(n, m, s.first, s.second, i);    // 执行一种操作，到达一种新的状态 
            
            // 若这一状态已达到过，则跳过 
            if ( min_t[new_s.first][new_s.second] >= 0 )    
                continue; 
            
            // 若这一状态没到达过，则记录新的min_t，计算新的ans，新状态入队 
            min_t[new_s.first][new_s.second] = min_t[s.first][s.second] + 1;
            ans = min(ans, abs(new_s.first+new_s.second-d));
            q.push(make_pair(new_s.first, new_s.second));
        } 
        if ( ans == 0 )    // 若期望的最小值已经为0，则没必要继续了。 
            break;
    }
    return ans;
} 

int main()
{
    int n, m, t, d;    // 两个杯子的容量，最大步骤数，期望的水量
    scanf("%d %d %d %d", &n, &m, &t, &d);
    printf("%d\n", bfs(n, m, t, d)); 
    return 0;
}

 

转载于:https://www.cnblogs.com/fyqq0403/p/10616358.html