求最大公约数（欧几里德算法）

求最大公约数的欧几里德算法，也称作辗转相除法，如下：

int GetGCD(int m, int n)
{
if (n = 0)
{
return m;
}
return GetGCD(n, m % n);
}
(GCD = Greatest Common Divisor)

比如
GetGCD(18, 24)
-> GetGCD(24, 18)
-> GetGCD(18, 6);
-> GetGCD(6, 0);
-> return 6;

----------------------------------------

另外，最小公倍数 = 两数之积 / 最大公约数
所以 GetLCM(m, n) = m * n / GetGCD(m, n)
(LCM = Least Common Multiple)

比如
GetLCM(18, 24) = 18 * 24 / 6 = 72

The two egg problem solution (copy-pasted from http://classic-puzzles.blogspot.com)

Google Interview Puzzle : 2 Egg Problem

My intention here is not to trouble Google interviewers. I was just collecting some classic puzzles and found this one and a small Google search showed me that this is a Google interview puzzle to my pleasant surprise. But many of the answers I found were either wrong or totally twisted. I am making no surety of the answer I give and I am open to your remarks or suggestion or corrections.

The Standard Problem in simple writing goes like this:

* You are given 2 eggs.
* You have access to a 100-storey building.
* Eggs can be very hard or very fragile means it may break if dropped from the first floor or may not even break if dropped from 100 th floor.Both eggs are identical.
* You need to figure out the highest floor of a 100-storey building an egg can be dropped without breaking.
* Now the question is how many drops you need to make. You are allowed to break 2 eggs in the process



If you are one of the people who likes to solve a puzzle before seeing the answer you must quit the blog now and come back later for checking the answer.


Now that this is a Google interview question I am taking the normal "Interview-Style" of solving a problem. Simply saying thinking aloud through the solution from worst to the best correcting the flows optimizing the solution or taking the 5-minute hard thinking acting pause to a problem, which you know already and just want to make your interviewer think that you are a challenge lover.

Solution

Drop the first egg from 50.If it breaks you can try the same approach for a 50-storey building (1 to 49) and try it from 25th floor. If it did not break try at 75th floor. And use linear search with the remaining portion of storey we need to test. For example if the first egg breaks at 50 we need to try all possibilities from 1 to 49.

Now this looks a feasible solution. In computer student's jargon do a binary search with first egg and linear search with the second one. Best case is log (100) and worst is 50.


Now the optimal solution for the problem is that you figure out that you will eventually end up with a linear search because you have no way of deciding the highest floor with only one egg (If you broke one egg and you have to find the answer among 10 all you can do is start from the lowest to the highest and the worst is the total number of floors). So the whole question grinds up to how to make use of the first egg to reduce the linear testing of the egg.


(For strict computer science students, well this problem can be solved using binary search on the number of drops needed to find the highest floor.)

Now let x be the answer we want, the number of drops required.

So if the first egg breaks maximum we can have x-1 drops and so we must always put the first egg from height x. So we have determined that for a given x we must drop the first ball from x height. And now if the first drop of the first egg doesn't breaks we can have x-2 drops for the second egg if the first egg breaks in the second drop.

Taking an example, lets say 16 is my answer. That I need 16 drops to find out the answer. Lets see whether we can find out the height in 16 drops. First we drop from height 16,and if it breaks we try all floors from 1 to 15.If the egg don't break then we have left 15 drops, so we will drop it from 16+15+1 =32nd floor. The reason being if it breaks at 32nd floor we can try all the floors from 17 to 31 in 14 drops (total of 16 drops). Now if it did not break then we have left 13 drops. and we can figure out whether we can find out whether we can figure out the floor in 16 drops.

Lets take the case with 16 as the answer

1 + 15 16 if breaks at 16 checks from 1 to 15 in 15 drops
1 + 14 31 if breaks at 31 checks from 17 to 30 in 14 drops
1 + 13 45 .....
1 + 12 58
1 + 11 70
1 + 10 81
1 + 9 91
1 + 8 100 We can easily do in the end as we have enough drops to accomplish the task


Now finding out the optimal one we can see that we could have done it in either 15 or 14 drops only but how can we find the optimal one. From the above table we can see that the optimal one will be needing 0 linear trials in the last step.

So we could write it as

(1+p) + (1+(p-1))+ (1+(p-2)) + .........+ (1+0) >= 100.

Let 1+p=q which is the answer we are looking for

q (q+1)/2 >=100

Solving for 100 you get q=14.
So the answer is: 14
Drop first orb from floors 14, 27, 39, 50, 60, 69, 77, 84, 90, 95, 99, 100... (i.e. move up 14 then 13, then 12 floors, etc) until it breaks (or doesn't at 100).

Please feel free to correct or post any comment on the solution or the answer.

0/1 KnapSack problem in C#

The following program find a best solution in 0/1 KnapSack problem, but it does not pick all the best solutions.

        public static int CalculateBagProblem(int BagVolumn, List<int> items, out List<int> chosenItems)

        {

            chosenItems = new List<int>();

            if (items.Count == 0)

            {  

                return 0;

            }

            else if (items.Count == 1)

            {

                if (items[0] <= BagVolumn)

                {

                    chosenItems.Add(items[0]);

                    return items[0];

                }

                else

                {

                    return 0;

                }

            }

            else

            {

                // without the first item

                List<int> remainItems = items.GetRange(1, items.Count - 1);

                List<int> chosenItemsInRemainItems = new List<int>();

                int withoutFirstItemResult = CalculateBagProblem(BagVolumn, remainItems, out chosenItemsInRemainItems);

                

                // with all the items

                int withFirstItemResult = 0;

                List<int> chosenItemsInItems = new List<int>();

                if (BagVolumn >= items[0])

                {

                    withFirstItemResult = CalculateBagProblem(BagVolumn - items[0], remainItems, out chosenItemsInItems) + items[0];

                    chosenItemsInItems.Add(items[0]);

                }

 

                // select max from the two results               

                if (withoutFirstItemResult >= withFirstItemResult)

                {

                    chosenItems = chosenItemsInRemainItems;

                    return withoutFirstItemResult;

                }

                else

                {

                    chosenItems = chosenItemsInItems;

                    return withFirstItemResult;

                }

            }

        }