C#内功修炼(算法)——贪心算法(五)

最新推荐文章于 2024-06-25 09:55:20 发布

鹅厂程序小哥

最新推荐文章于 2024-06-25 09:55:20 发布

阅读量587

点赞数

分类专栏： C# 数据结构与算法文章标签： C#

C# 同时被 2 个专栏收录

107 篇文章 10 订阅

订阅专栏

数据结构与算法

47 篇文章 12 订阅

订阅专栏

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

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

贪心算法 - 活动选择问题

有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的最大兼容活动子集的大小，对于上述问题就是求c[0,12]的解

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的集合，然后求得最大兼容子集

[csharp]view plain copy
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<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++)  
            {  
                // S[ij] i结束之后 j开始之前的 活动集合  
                // f[i]  s[j] 这个时间区间内的所有活动  
                List<int> sij = new List<int>();  
                for (int number = 1; number < s.Length - 1; number++)  
                {  
                    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)  
                    {  
                        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的某个最大兼容活动子集中。

（如何证明上面的结论？反证法）

递归解决

[csharp]view plain copy
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 };  
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;  
        }  
    }  
    List<int> list = ActivitySelection(tempNumber + 1, endActivityNumber, f[tempNumber], endTime);  
    list.Add(tempNumber);  
    return list;  
}  

迭代解决

[csharp]view plain copy
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();  
}  

贪心算法 - 钱币找零问题

这个问题在我们的日常生活中就更加普遍了。假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0,c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元，至少要用多少张纸币？用贪心算法的思想，很显然，每一步尽可能用面值大的纸币即可。

intCount[N]={3,0,2,1,0,3,5};

intValue[N]={1,2,5,10,20,50,100};

[csharp]view plain copy
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();  
  
}  
  
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])//我们有的纸币的钱的总额，比k要小  
        {  
            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;  
}  