算法(5)——贪心算法

对于许多最优化问题，使用动态规划算法来求最优解有些杀鸡用牛刀了，可以使用更加简单、更加高效的算法。贪心算法就是这样的算法，它在每一步做出当时看起来最佳的选择。也就是说它总是做出局部最优的选择，从而得到全局最优解。

对于某些问题并不保证得到最优解，但对很多问题确实可以求得最优解。

有n个需要在同一天使用同一个教室的活动a1,a2,…,an，教室同一时刻只能由一个活动使用。每个活动ai都有一个开始时间si和结束时间fi 。一旦被选择后，活动ai就占据半开时间区间[si,fi)。如果[si,fi]和[sj,fj]互不重叠，ai和aj两个活动就可以被安排在这一天。该问题就是要安排这些活动使得尽量多的活动能不冲突的举行（最大兼容活动子集）。例如下图所示的活动集合S，其中各项活动按照结束时间单调递增排序。

{a3,a9,a11}是一个兼容的活动子集，但它不是最大子集，因为子集{a1,a4,a8,a11}更大，实际上它是我们这个问题的最大兼容子集，但它不是唯一的一个{a2，a4，a9，a11}

1，动态规划算法解决思路

我们使用Sij代表在活动ai结束之后，且在aj开始之前的那些活动的集合，我们使用c[i,j]代表Sij的最大兼容活动子集的大小

  a, 当i>=j-1或者Sij 中没有任何活动元素的时候， c[i,j]=0

  b，当i<j-1

          1，Sij不存在活动,c[i,j]=0

          2，Sij存在活动的时候，c[i,j]= max{c[i,k]+c[k,j]+1}  ak属于Sij,这里是遍历Sij的集合，然后求得最大兼容子集

 

    class Program
    {
        static void Main(string[] args)
        {
            //活动开始时间
            int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 24 };
            //活动结束时间
            int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 24 };

            //list类型的二维数组，
            List<int>[,] result = new List<int>[13, 13];// 默认值null
            for (int m = 0; m < 13; m++)
            {
                for (int n = 0; n < 13; n++)
                {
                    result[m, n] = new List<int>();
                }
            }//初始化一个空list集合

            for (int j = 0; j < 13; j++)
            {
                for (int i = 0; i < j - 1; i++)
                {
                    
                    // f[i]  s[j] 这个时间区间内的所有活动
                    List<int> sij = new List<int>();// S[ij] i结束之后 j开始之前的 活动集合
                    for (int number = 1; number < s.Length - 1; number++)
                    {
                        //活动开始时间>i结束之后    活动的结束时间<j开始之前
                        if (s[number] >= f[i] && f[number] <= s[j])
                        {
                            sij.Add(number);
                        }
                    }

                    if (sij.Count > 0)
                    {
                        //result[i,j]=max{ result[i,k]+result[k,j]+ k }

                        int maxCount = 0;
                        List<int> tempList = new List<int>();//临时集合，保存最大容量的子集数据
                        foreach (int number in sij)
                        {
                            //数目包含从i到number,从number到j,再加上自身number
                            int count = result[i, number].Count + result[number, j].Count + 1;
                            if (maxCount < count)
                            {
                                maxCount = count;
                                tempList = result[i, number].Union<int>(result[number, j]).ToList<int>();
                                tempList.Add(number);
                            }
                        }
                        result[i, j] = tempList;
                    }

                }
            }
            List<int> l = result[0, 12];
            foreach (int temp in l)
            {
                Console.WriteLine(temp);
            }
            Console.ReadKey();
        }
    }

2，贪心算法

  想要使用贪心算法的话，得先找到适合贪心算法的规律（局部最优选择）

  对于任何非空的活动集合S，假如am是S中结束时间最早的活动，则am一定在S的某个最大兼容活动子集中。

  贪心算法递归方式实现

namespace 活动选择问题___贪心算法___递归解决
{
    class Program
    {
        static void Main(string[] args)
        {

            List<int> list = ActivitySelection(1, 11, 0, 24);
            foreach (int temp in list)
            {
                Console.WriteLine(temp);
            }
            Console.ReadKey();

        }
        static int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
        static int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
        /// <summary>
        /// 
        /// </summary>
        /// <param name="startActivityNumber">开始活动的编号</param>
        /// <param name="endActivityNumber">结束活动的编号</param>
        /// <param name="startTime">区间的开始时间</param>
        /// <param name="endTime">区间结束的时间</param>
        /// <returns></returns>
        public static List<int> ActivitySelection(int startActivityNumber,int endActivityNumber,int startTime ,int endTime)
        {
            //没有活动间隙或者没有活动时间，递归终止
            if (startActivityNumber > endActivityNumber || startTime >= endTime)
            {
                return new List<int>();
            }
            //找到结束时间最早的活动 
            int tempNumber = 0;
            for (int number = startActivityNumber; number <= endActivityNumber; number++)
            {
                if (s[number] >= startTime && f[number] <= endTime)
                {
                    tempNumber = number;
                    break;
                }
            }
            //除了tempNumber，剩余时间中的活动子集
            List<int> list = ActivitySelection(tempNumber + 1, endActivityNumber, f[tempNumber], endTime);
            list.Add(tempNumber);
            return list;
        }
    }
}

贪心算法迭代方式实现

namespace 活动选择问题___贪心算法___迭代解决
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
            int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

            int startTime = 0;
            int endTime = 24;
            List<int> list = new List<int>();
            for (int number = 1; number <= 11; number++)
            {
                if (s[number] >= startTime && f[number] <= endTime)
                {
                    list.Add(number);
                    startTime = f[number];
                }
            }
            foreach (int i in list)
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();
        }
    }
}

贪心算法纸币兑换

namespace 钱币找零问题___贪心算法
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] count={3,0,2,1,0,3,5};  
            int[] amount={1,2,5,10,20,50,100};
            //            0 0 2 1   0   0 3
            int[] result = Change(324, count, amount);
            foreach (int i in result)
            {
                Console.Write(i + " ");
            }
            Console.ReadKey();

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="k">要兑换的钱数</param>
        /// <param name="count">有的零钱的数目</param>
        /// <param name="amount">拥有的零钱的额度</param>
        /// <returns></returns>
        public static int[] Change(int k, int[] count, int[] amount)
        {
            if (k == 0) return new int[amount.Length + 1];
            int total = 0;
            int index = amount.Length - 1;
            //需要的每种钱币的数目
            int[] result = new int[amount.Length+1];
            while (true)
            {
                //钱还完了或者钱不够还，循环终止
                if (k <= 0 || index <= -1) break;
                //钱数大于当前索引钱数的总和
                if (k > count[index] * amount[index])
                {
                    result[index] = count[index];
                    k -= count[index] * amount[index];
                }
                else
                {
                    result[index] = k / amount[index];
                    k -= result[index] * amount[index];
                }
                index--;
            }
            result[amount.Length] = k;
            return result;
        }
    }
}