考CSDN最牛B的程序员！

Question

有十公斤水， 现在有三个桶  一个是十公斤的一个是七公斤 一个是三公斤的 让你把十公斤水分成 两个 每份为五公斤   怎么分？
本人已经给出了答案：
请高手帮忙写一个算法出来！
10 0 0
3 7 0
3 4 3
6 4 0
6 1 3
9 1 0
9 0 1
2 7 1
2 5 3
5 5 0

Answer 1

楼主的意思是做出来就是CSDN最牛B的程序员了吗?

Answer 2

貌似不算太难吧,有个大致的思路
三个桶子a,b,c对应10,7,3
如果C里面没水或者没满就从B里面倒水
如果B里面没水就从A里面倒水
如果C满了把C的倒给A
这样执行下来是
10,0,0
3,7,0
3,4,3
6,4,0
6,1,3
9,1,0
9,0,1
2,7,1
2,5,3
5,5,0
没错吧~~

Answer 3

我是菜鸟,但你一定要给分using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication4
{
    enum States { Empty, Half, Full } 
    //水桶类        
    public class Bucket
    {
        private States _state;
        internal States State
        {
            get { return _state; }
            set { _state = value; }
        }        private int _capacity;
        public int Capacity
        {
            get { return _capacity; }
            set { _capacity = value; }
        }        private int _water;
        public int Water
        {
            get { return _water; }
            set { _water = value; }
        }
        public Bucket(int capacity)
        {
            this.Capacity = capacity;
            this.State = States.Empty;
            this.Water = 0;
        }        public void CheckState()
        {
            if (this.Water == this.Capacity)
            {
                this.State = States.Full;
            }
            else
                if (this.Water == 0)
                {
                    this.State = States.Empty;
                }
                else
                {
                    this.State = States.Half;
                }
        }
    }
}using System;
using System.Collections.Generic;
using System.Text;namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            Bucket b10 = new Bucket(10);
            b10.Water = 10;
            b10.CheckState();
            Bucket b7 = new Bucket(7);
            Bucket b3 = new Bucket(3);
            while (!((b10.Water == 5) && (b7.Water == 5)))
            {
                if (b3.State != States.Full)
                {
                    Change(b7, b3);
                    Console.Write(b10.Water);
                    Console.Write(b7.Water);
                    Console.WriteLine(b3.Water);
                    if (b7.State == States.Empty)
                    {
                        Change(b10, b7);
                        Console.Write(b10.Water);
                        Console.Write(b7.Water);
                        Console.WriteLine(b3.Water);
                    }
                    else
                        if (b3.State == States.Full)
                        {
                            Change(b3, b10);
                            Console.Write(b10.Water);
                            Console.Write(b7.Water);
                            Console.WriteLine(b3.Water);
                        }
                }
            }
            
        }        public static void Change(Bucket bucketOut, Bucket bucketIn)
        {
            if (bucketOut.Water >= (bucketIn.Capacity - bucketIn.Water))
            {
                bucketOut.Water = bucketOut.Water - (bucketIn.Capacity - bucketIn.Water);
                bucketIn.Water = bucketIn.Capacity;
                bucketIn.CheckState();
                bucketOut.CheckState();
            }
            else
            {
                bucketIn.Water = bucketIn.Water + bucketOut.Water;
                bucketOut.Water = 0;
                bucketIn.CheckState();
                bucketOut.CheckState();
            }
        }
    }
}输出:
1000
370
343
640
613
910
901
271
253
550

Answer 4

呵呵 看了楼上的 只是针对这一特定值的特定情况
我还没写完呢 是想写个通用的 不过要判断成立条件涉及的内容太多啦 总的思路如下：
设三个容器A，B，C的容积分别是a,b,c,要量出的容量为m
1 m不能大于a,b,c中的最大值
2 m必须不能同大于两个容器的最大容积
3 将a,b,c排序（为简便设a>b>c），以C为对象容器，取B为中转容器，A为初始容器（满），必须满足以下条件之一
  （1）m是c的倍数
  （2）m=c倍数与b之差
  （3）m=c倍数与a之差或许还有别的可能 把这些判断完成以后 才可以写后面的程序

Answer 5

改进了一下,之前的算法有点逻辑问题,现在的能处理绝大部分排序,然后是灵活性
只要在入口里面指定三个桶的大小,以及要分出来的水量//Bucket类没改using System;
using System.Collections.Generic;
using System.Text;namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            Achieve(20, 11, 9, 10, 10);            
        }        public static void Change(Bucket bucketOut, Bucket bucketIn)
        {
            if (bucketOut.Water >= (bucketIn.Capacity - bucketIn.Water))
            {
                bucketOut.Water = bucketOut.Water - (bucketIn.Capacity - bucketIn.Water);
                bucketIn.Water = bucketIn.Capacity;
                bucketIn.CheckState();
                bucketOut.CheckState();
            }
            else
            {
                bucketIn.Water = bucketIn.Water + bucketOut.Water;
                bucketOut.Water = 0;
                bucketIn.CheckState();
                bucketOut.CheckState();
            }
        }        public static void Achieve(int big,int middle,int small,int result1,int result2 )
        {
            Bucket bBig = new Bucket(big);
            bBig.Water = big;
            bBig.CheckState();
            Bucket bMiddle = new Bucket(middle);
            Bucket bSmall = new Bucket(small);
            while (!((bBig.Water == result1) && (bMiddle.Water == result2)))
            {
                if (bSmall.State != States.Full)
                {
                    Change(bMiddle, bSmall);
                    Console.Write(bBig.Water);
                    Console.Write(bMiddle.Water);
                    Console.WriteLine(bSmall.Water);
                    if (bMiddle.State == States.Empty)
                    {
                        Change(bBig, bMiddle);
                        Console.Write(bBig.Water);
                        Console.Write(bMiddle.Water);
                        Console.WriteLine(bSmall.Water);
                    }
                    
                }
                else
                    if (bSmall.State == States.Full)
                    {
                        Change(bSmall, bBig);
                        Console.Write(bBig.Water);
                        Console.Write(bMiddle.Water);
                        Console.WriteLine(bSmall.Water);
                    }
                if ((bMiddle.State==States.Full)&&(bSmall.State==States.Full))
                {
                    Console.WriteLine("没有答案!");
                    break;
                }
            }
        }    }
}
输出:
2000
9110
929
1820
1802
7112
749
1640
1604
5114
569
1460
1406
3116
389
1280
1208
1118
1109
10100

Answer 6

汗,想把调用的部分打个颜色
结果变成了
  Achieve(20, 11, 9, 10, 10);            

Answer 7

菜鸟是因为不太熟悉.net类库,无聊的时候写写算法还是不错的^^