UVa 10603 - Fill

最新推荐文章于 2022-07-23 22:15:14 发布

原创最新推荐文章于 2022-07-23 22:15:14 发布 · 617 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

338 篇文章

订阅专栏

本文介绍UVa10603-Fill问题的解题思路，通过隐式图搜索（BFS）解决水量转移问题。详细解释了如何利用二维vis数组记录状态，并在每轮搜索前清空队列，避免重复计算。提供了两种实现方式及运行时间对比。

题目链接：UVa 10603 - Fill

隐式图：仅给出初始结点、目标结点以及生成子结点的约束条件（题意隐含给出），要求按扩展规则应用于扩展结点的过程，找出其他结点，，直到包含目标结点为止。结点也可以说成状态。

这道题是隐式图搜索，其实就是用BFS。这里要注意一下vis数组，这里开二维数组就可以了，原因就是开始水量已经给出了，那么三个水杯中只要有两个水杯的水量确定了，那么第三个水杯的水量就确定了。还有需要注意的是，每一次要把队列清空，因为这个WA了几次。写了两个代码，第二个比第一个快一点，不过也差不太多。

这道题应该是可以使用hash做，可能这样也快点，不太懂怎么设计。

/**
0.032s
*/
/**
5
12 23 42 14
12 53 75 23
56 23 34 2
23 55 72 25
124 86 173 84
*/
#include <iostream>
#include <queue>
#include <cstring>

const int MAX_S = 201 * 201 + 100;//最多有201 * 201个状态
const int MAX_N = 201 + 5;
const int N = 3;
using namespace std;

struct status
{
    int remain[N];
    int _min;
};//状态
int vis[MAX_N][MAX_N];
int d,a,b,c;
int T;
int cal[N];//容量
int _min,_d;
bool flag;
queue<status> q;

void bfs()
{
    status s;
    s.remain[0] = s.remain[1] = 0;
    s.remain[2] = cal[2];
    s._min = 0;
    vis[s.remain[0]][s.remain[1]] = 1;
    q.push(s);
    while(!q.empty())
    {
        s = q.front();
        q.pop();
        for(int i = 0;i < N;i++)
        {
            if(s.remain[i] == d)
            {
                _min = s._min;
                flag = true;
                return ;
            }
            else
            {
                if(s.remain[i] > _d && s.remain[i] < d)
                {
                    _min = s._min;
                     _d = s.remain[i];
                }
            }
        }
        for(int i = 0;i < N;i++)
        {
            if(!s.remain[i])
                continue;
            for(int j = 0;j < N;j++)
            {
                //status s_next = s;
                status s_next;
                s_next = s;
                //memcpy(s_next,s,sizeof(s));
                //从第i个杯子向第j个杯子倒水
                if(i != j && s.remain[i] && s.remain[j] < cal[j])
                {
                    int tr = s.remain[i];
                    if(cal[j] - s.remain[j] < s.remain[i])
                        tr = cal[j] - s.remain[j];

                    s_next._min += tr;
                    s_next.remain[i] -= tr;
                    s_next.remain[j] += tr;

                    if(!vis[s_next.remain[0]][s_next.remain[1]])
                    {
                        vis[s_next.remain[0]][s_next.remain[1]] = 1;
                        q.push(s_next);
                    }
                }
            }
        }
    }
}
int main()
{
    cin>>T;
    while(T--)
    {
        while(!q.empty())
            q.pop();
        flag = false;
        memset(vis,0,sizeof(vis));
        _min = 0;
        _d = 0;
        cin>>cal[0]>>cal[1]>>cal[2];
        cin>>d;
        bfs();
        if(flag)
            cout<<_min<<" "<<d<<endl;
        else
            cout<<_min<<" "<<_d<<endl;
    }
    return 0;
}

/**
0.022s
*/
/**
5
12 23 42 14
12 53 75 23
56 23 34 2
23 55 72 25
124 86 173 84
*/
#include <iostream>
#include <queue>
#include <cstring>

const int MAX_S = 201 * 201 + 100;//最多有201 * 201个状态
const int MAX_N = 201 + 5;
const int N = 3;
using namespace std;

struct status
{
    int remain[N];
    int _min;
};//状态
int vis[MAX_N][MAX_N];
int d,a,b,c;
int T;
int cal[N];//容量
int _min,_d;
bool flag;
queue<status> q;

void bfs()
{
    status s;
    s.remain[0] = s.remain[1] = 0;
    s.remain[2] = cal[2];
    s._min = 0;
    vis[s.remain[0]][s.remain[1]] = 1;
    q.push(s);
    while(!q.empty())
    {
        s = q.front();
        q.pop();
        for(int i = 0;i < N;i++)
        {
            if(s.remain[i] == d)
            {
                _min = s._min;
                flag = true;
                return ;
            }
            else
            {
                if(s.remain[i] > _d && s.remain[i] < d)
                {
                    _min = s._min;
                     _d = s.remain[i];
                }
            }
        }
        for(int i = 0;i < N;i++)
        {
            for(int j = i + 1;j < N;j++)
            {
                status s_next;
                s_next = s;
                if(s.remain[i] && s.remain[j] < cal[j])
                {
                    int tr = s.remain[i];
                    if(cal[j] - s.remain[j] < s.remain[i])
                        tr = cal[j] - s.remain[j];

                    s_next._min += tr;
                    s_next.remain[i] -= tr;
                    s_next.remain[j] += tr;

                    if(!vis[s_next.remain[0]][s_next.remain[1]])
                    {
                        vis[s_next.remain[0]][s_next.remain[1]] = 1;
                        q.push(s_next);
                    }
                }
                else if(s.remain[j] && s.remain[i] < cal[i])
                {
                    int tr = s.remain[j];
                    if(cal[i] - s.remain[i] < s.remain[j])
                        tr = cal[i] - s.remain[i];

                    s_next._min += tr;
                    s_next.remain[j] -= tr;
                    s_next.remain[i] += tr;

                    if(!vis[s_next.remain[0]][s_next.remain[1]])
                    {
                        vis[s_next.remain[0]][s_next.remain[1]] = 1;
                        q.push(s_next);
                    }
                }
            }
        }
    }
}
int main()
{
    cin>>T;
    while(T--)
    {
        while(!q.empty())
            q.pop();
        flag = false;
        memset(vis,0,sizeof(vis));
        _min = 0;
        _d = 0;
        cin>>cal[0]>>cal[1]>>cal[2];
        cin>>d;
        bfs();
        if(flag)
            cout<<_min<<" "<<d<<endl;
        else
            cout<<_min<<" "<<_d<<endl;
    }
    return 0;
}