uva 10603 倒水问题

刘汝佳说这是一道最短路，可是我怎么也想不出如何建图，把问题转换为最短路问题，我就想自己的办法。感觉这个题可以用三维dp；每一维代表一个瓶子            f[maxn][maxn][maxn]；状态转移我就想：每一次倒水一定要把一个倒完或把另一个装满才有意义，因为只有这样三个瓶的水量才知道；所以可以根据这个进行状态转移。状态转移代码有点啰嗦，主要是不同维不能统一一个式子。最后想到用队列来存变化的状态。

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <queue>
#include <cstring>
#define maxn 205
using namespace std;

const int INF = 0x3f3f3f;

int f[maxn][maxn][maxn];
int maxi,maxj,maxk,maxd;
struct node{
    int i,j,k;
}Node;
int i,j,k;
int ansnum,ans;
queue<node> Q;
int T;
void print(){

    printf("%d %d %d      %d %d %d     %d \n",i,j,k,Node.i,Node.j,Node.k,f[Node.i][Node.j][Node.k]);
}

int main()
{
    //if(freopen("input.txt","r",stdin)== NULL)  {printf("Error\n"); exit(0);}
    //if(freopen("output.txt","w",stdout)== NULL)  {printf("Error\n"); exit(0);}
    cin>>T;
    while(T--){
        cin>>maxi>>maxj>>maxk>>maxd;
        memset(f,0x3f,sizeof(f));
        while(!Q.empty())  Q.pop();
        f[0][0][maxk] = 0;
        Node.i = 0;  Node.j = 0;  Node.k = maxk;
        Q.push(Node);
        while(!Q.empty()){
            Node = Q.front(); Q.pop();
            i = Node.i; j = Node.j;  k = Node.k;  
            
            if(i != maxi){
               if(j >= (maxi - i)){
                 Node.j = j - (maxi - i);  Node.i = maxi;  Node.k = k;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxi - i){
                       f[Node.i][Node.j][Node.k] = f[i][j][k] + maxi - i;
                       Q.push(Node); 
                    }
               }
                  else{
                       Node.j = 0 ;  Node.i = j + i;  Node.k = k;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + j){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + j;
                     Q.push(Node); 
                    }
                  }
                  if(k >= (maxi - i)){
                 Node.j = j;  Node.k = k - (maxi - i);  Node.i = maxi;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxi - i){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + maxi - i;
                     Q.push(Node);  
                   }
                  }
                  else{
                       Node.j = j;  Node.i = k + i;  Node.k = 0;
                
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + k){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + k;
                     Q.push(Node);  
                    }
                  }
                }
            if(j != maxj){
               if(i >= (maxj - j)){
                 Node.j = maxj;  Node.i = i - (maxj - j);  Node.k = k;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxj - j){
                       f[Node.i][Node.j][Node.k] = f[i][j][k] + maxj - j;
                       Q.push(Node); 
                    }
               }
                  else{
                       Node.j = j + i;  Node.i = 0;  Node.k = k;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + i){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + i;
                     Q.push(Node);  
                    }
                  }
                  if(k >= (maxj - j)){
                 Node.j = maxj;  Node.i = i;  Node.k = k - (maxj - j);
                
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxj - j){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + maxj - j;
                     Q.push(Node);  
                   }
                  }
                  else{
                       Node.j = j + k;  Node.i = i;  Node.k = 0;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + k){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + k;
                     Q.push(Node);  
                    }
                  }
                
               }
            
            if(k != maxk){
               if(i >= (maxk - k)){
                 Node.j = j;  Node.k =maxk;  Node.i = i - (maxk - k);
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxk - k){
                       f[Node.i][Node.j][Node.k] = f[i][j][k] + maxk - k;
                       Q.push(Node);  
                    }
               }
                  else{
                       Node.j = j;  Node.i = 0;  Node.k = k + i;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + i){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + i;
                     Q.push(Node);  
                    }
                  }
                  if(j >= (maxk - k)){
                 Node.k = maxk;  Node.j = j - (maxk - k);  Node.i = i;
                
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + maxk - k){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + maxk - k;
                     Q.push(Node);  
                   }
                  }
                  else{
                       Node.k = k + j;  Node.i = i;  Node.j = 0;
                 
                 if(f[Node.i][Node.j][Node.k] > f[i][j][k] + j){
                     f[Node.i][Node.j][Node.k] = f[i][j][k] + j;
                     Q.push(Node);  
                    }
                  }
                }
        }
        ans = 0;ansnum = INF;
        for(int m = maxd;m>=0;m--){
            for(int n = 0;n <= maxk - m ;n++){
                if(f[m][maxk - m - n][n] < ansnum){
                    ans = m; ansnum = f[m][maxk - m - n][n]; 
                }
                if( ansnum > f[m][n][maxk - m - n]){
                    ans = m; ansnum = f[m][n][maxk - m - n]; 
                }
                if(f[maxk - m - n][m][n] < ansnum){
                    ans = m; ansnum =f[maxk - m - n][m][n];  
                }
                if(f[n][m][maxk - m - n] < ansnum){
                    ans = m; ansnum =f[n][m][maxk - m - n];  
                }
                if(f[n][maxk - m - n][m] < ansnum){
                    ans = m; ansnum =f[n][maxk - m - n][m];  
                }
                if(f[maxk - m - n][n][m] < ansnum){
                    ans = m; ansnum =f[maxk - m - n][n][m];  
                }
               }
          if(ans) break;
        }
        printf("%d %d\n",ansnum,ans);
    }
}  

等一会看看别人的解题法，如何用最短路