uva 10603 状态压缩& 最短路

题意：有3个杯子 ， 每个杯子的容量分别为： a 、 b、 c ， 前两个杯子都是空的 ， 第三个杯子的满的 ， 问 ，让任意一个杯子中有确定L升水 ， 最少需要倒多少升水。

解法： 其实这个题目可以看成是一个隐式图搜索的问题 ， 直接用dfs就能解决 ， 这里用最短路 ， 那么我们就要先把图建立好 ，（a，b）这表示一个状态 ， 那么我们把每个这样的状态看成是一个点 ， 建图时 ， 就判断这个点可以到达哪些点 ， 如果能到达 ，就连一条有向边 ， 边的权值为所倒水的多少。

代码：
#include
#include
#include
#include
#include
using namespace std;

#define maxn 210
#define INF 1000000000
#define min(x , y) (x)>(y)?(y):(x)
struct node
{
      int u;
      int d;
};

struct node1
{
      int d ,u;
      booloperator < (const node1 &rhs)const
      {
            return d>= rhs.d;
      }
};

vectorgrap[maxn*maxn];
int xy[maxn][maxn];
int a , b , c , d;
int dist[maxn*maxn] , pre[maxn*maxn];
int minx , my;

int n;

void init()
{
      int i ,j;
      for(i = 0; i<= c*c+1; i++)
            grap[i].clear();

      memset(xy ,-1 , sizeof(xy));
      int e =0;
      int x =min(c , a) , y = min(c , b);
      for(i = 0; i<= x; i++)
            for(j = 0; j<= y; j++)
                  if(i+j<= c)
                        xy[i][j] =e++;

      n =e-1;

}

void creat(int x , int y)
{
     
      int z =c-x-y;
      int g =xy[x][y] , h;
      nodee;

      if(x> b-y)
      {
            h =xy[x-b+y][b];
            if(h !=g)
            {
                  e.u =h;
                  e.d =b-y;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[0][x+y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =x;
                  grap[g].push_back(e);
            }
      }
      if(x> c-z)
      {
            h =xy[x-c+z][y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =c-z;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[0][y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =x;
                  grap[g].push_back(e);
            }
      }


      if(y> a-x)
      {
            h =xy[a][y-a+x];
            if(h !=g)
            {
                  e.u =h;
                  e.d =a-x;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[x+y][0];
            if(h !=g)
            {
                  e.u =h;
                  e.d =y;
                  grap[g].push_back(e);
            }
      }
      if(y> c-z)
      {
            h =xy[x][y-c+z];
            if(h !=g)
            {
                  e.u =h;
                  e.d =c-z;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[x][0];
            if(h !=g)
            {
                  e.u =h;
                  e.d =y;
                  grap[g].push_back(e);
            }
      }


      if(z> b-y)
      {
            h =xy[x][b];
            if(h !=g)
            {
                  e.u =h;
                  e.d =b-y;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[x][z+y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =z;
                  grap[g].push_back(e);
            }
      }
      if(z> a-x)
      {
            h =xy[a][y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =a-x;
                  grap[g].push_back(e);
            }
      }
      else
      {
            h =xy[x+z][y];
            if(h !=g)
            {
                  e.u =h;
                  e.d =z;
                  grap[g].push_back(e);
            }
           
      }
}

void dijkstra()
{
      priority_queueq;
      int i ,j;

      node1e;
      nodef;

      e.d = 0 ,e.u = 0;
      q.push(e);
      for(i = 0; i<= n; i++) dist[i] = INF;
      memset(pre ,0 , sizeof(pre));
      dist[0] =0;
     
      while(!q.empty())
      {
            e =q.top();  q.pop();
            int u =e.u;

            if(pre[u])  continue;
            pre[u] =1;

            for(i = 0; i< grap[u].size(); i++)
            {
                  f =grap[u][i];
                  if(dist[u]+f.d < dist[f.u])
                  {
                        dist[f.u] =dist[u]+f.d;
                        e.d =dist[f.u] ;
                        e.u =f.u;
                        q.push(e);
                       
                  }
            }
      }
}

int main()
{
      int t;
      cin>>t;
      while(t--)
      {
            scanf("%d %d%d %d" , &a , &b ,&c , &d);

            if(c ==d)
            {
                  printf("%d%d\n" , 0 , d);
                  continue;
            }
            init();
           
            int i ,j;
            for(i = 0; i<= c; i++)
                  for(j = 0; j<= c; j++)
                        if(xy[i][j]!= -1)  creat(i , j);


            dijkstra();
           
            int minx =INF;

            int x =min(a , c) , y = min(b , c);

            for(int k =d; k >= 0; k--)
            {
                  minx =INF;
                  for(i = 0; i<= x; i++)
                  {
                        for(j = 0; j<= y; j++)
                              if(xy[i][j]!= -1 &&(i==k||j==k||(c-i-j)==k))
                                    minx =min(minx , dist[xy[i][j]]);
                  }

                  if(minx !=INF)
                  {
                        printf("%d%d\n" , minx , k);
                        break;
                  }
            }

           
      }
      return0;
}