倒水问题：给定两个没有刻度的容器，对于任意给定的容积，求出如何只用两个瓶装出L升的水，如果可以，输出步骤，如果不可以，输出no solution

倒水问题：给定两个没有刻度的容器，对于任意给定的容积，求出如何只用两个瓶装出L升的水，如果可以，输出步骤，如果不可以，输出no solution

这个问题我找了百度，发现没有比较好的代码，有一些只判断了有没有解决方案，还有一些代码写的太长了，难看。所以在这里简单解决一下。

首先，由于要输出步骤，而且不一定能成功，A,B,L都是未知的，所以不能用动态规划解决。

首先是判断能否装出L升的水。

这个问题百度有相关代码，简单来说就是用辗转相除法的一个性质去判断

//是否存在整数x,y使得给定系数A,B,C满足等式：A*x+B*y=C
//若这样的二元一次方程存在整数解，则有C%gcd(A,B)==0，其中		
gcd（A,B）函数为求A,B的最大公约数
//其实就是欧几里得算法 的一个应用，听说过就会，没听过就不会

接下来如果可以装，那么就用DFS回溯法，其实这题和骑士游历还有八皇后是一样的，而且更加简单一些。

这里给大家道个歉，之前的代码，能装出的装水漏了一种情况，现在已经更正。
容器能装出水的成分为 a , b, a-b, n * b - a;
前三个都好理解，这里解释一下n b - a;
比如a = 11; b = 5; 则n为 令不等式 nb>a 成立的最小正整数；
代码解释如下

for (n = 1; n * b < a; n++) {
	    	continue;
		}

这个是之前遗漏的地方。现在已经更正。

那么直接贴代码了
核心代码其实只有backtrack函数
注意，这里没有判断malformed input，想加的可以加上，再把风格换成自己的，就是一份原创的代码了呢 [doge]

#include<iostream>
#include<vector>
using namespace std;

int can(int a, int b, int c);
int gcd(int a, int b);
void BackTrack(int cup[4], int& current, int& target, vector<int>& trail,
        vector<int>& solution);

int can(int a, int b, int c) {
    if (c <= 1000000000) {
        int d = gcd(a, b);
        if (c % d == 0)
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

int gcd(int a, int b) {
    if (b == 0)
        return a;
    while (b != 0) {
        int r = b;
        b = a % b;
        a = r;
    }
}

void BackTrack(int cup[4], int& current, int& target, vector<int>& trail, vector<int>& solution) {
    if (current == target) {
        solution = trail;
    }
    else {
        for (int i = 0; i < 4; i++) {
            if (cup[i] + current > target) {
                continue;
            }
            else {
                trail.push_back(cup[i]);
                current += cup[i];
                BackTrack(cup, current, target, trail, solution);
                current -= cup[i];
                trail.pop_back();
            }
        }
    }
}

int main(void) {
    cout << "输入容器A,B和要装出的水C,注意，请输入整数，而且A > B:" << endl;
    int a, b, c, n;
    int volumn[4];
    cin >> a >> b >> c;
    volumn[0] = a;
    volumn[1] = b;
    volumn[2] = a - b;
    for (n = 1; n * b < a; n++) {
    	continue;
	}
	volumn[3] = n * b - a;
	for (int i = 0; i < 4; i++) {
		cout<<volumn[i]<<"  ";
	}
	cout<<endl;
    int current = 0;
    vector<int> trail;
    vector<int> solution;
    if (can(a, b, c)) {
        cout << "can!" << endl;
        BackTrack(volumn, current, c, trail, solution);
        for (auto i : solution) {
            cout << i << endl;
        }
    }
    else
    cout << "can't!" << endl;
    return 0;
}