贪心算法及几个常用的例题

贪心算法:
一、基本概念:

 所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。
 贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。
所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

二、贪心算法的基本思路:

1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解,得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。

三、贪心算法适用的问题

贪心策略适用的前提是:局部最优策略能导致产生全局最优解。
实际上,贪心算法适用的情况很少。一般,对一个问题分析是否适用于贪心算法,可以先选择该问题下的几个实际数据进行分析,就可做出判断。

四、贪心算法的实现框架

从问题的某一初始解出发;
while (能朝给定总目标前进一步)
{ 
      利用可行的决策,求出可行解的一个解元素;
}
由所有解元素组合成问题的一个可行解;

五、贪心策略的选择

 因为用贪心算法只能通过解局部最优解的策略来达到全局最优解,因此,一定要注意判断问题是否适合采用贪心算法策略,找到的解是否一定是问题的最优解。

几个经典的例子:

一、定义

什么是贪心算法呢?所谓贪心算法是指,在对问题求解时,总是做出在当前看来最好的选择。也就是说,不从整体最优解出发来考虑,它所做出的仅是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。

贪心算法的基本思路如下:

 1. .建立数学模型来描述问题。
 2. 把求解的问题分成若干个子问题。
 3. 对每个子问题求解,得到每个子问题的局部最优解。
 4. 把每个子问题的局部最优解合成为原来问题的一个解。

二、例题分析

[背包问题]有一个背包,背包容量是M=150。有7个物品,物品可以分割成任意大小。

要求尽可能让装入背包中的物品总价值最大,但不能超过总容量。

物品 A B C D E F G

重量 35 30 60 50 40 10 25

价值 10 40 30 50 35 40 30

记得当时学算法的时候,就是这个例子,可以说很经典。

分析:

目标函数: ∑pi最大

约束条件是装入的物品总重量不超过背包容量,即∑wi<=M( M=150)

(1)根据贪心的策略,每次挑选价值最大的物品装入背包,得到的结果是否最优?

(2)每次挑选所占重量最小的物品装入是否能得到最优解?

(3)每次选取单位重量价值最大的物品,成为解本题的策略?

贪心算法是很常见的算法之一,这是由于它简单易行,构造贪心策略简单。但是,它需要证明后才能真正运用到题目的算法中。一般来说,贪心算法的证明围绕着整个问题的最优解一定由在贪心策略中存在的子问题的最优解得来的。

对于本例题中的3种贪心策略,都无法成立,即无法被证明,解释如下:

(1)贪心策略:选取价值最大者。反例:

W=30

物品:A B C

重量:28 12 12

价值:30 20 20

根据策略,首先选取物品A,接下来就无法再选取了,可是,选取B、C则更好。

(2)贪心策略:选取重量最小。它的反例与第一种策略的反例差不多。

(3)贪心策略:选取单位重量价值最大的物品。反例:

W=30

物品:A B C

重量:28 20 10

价值:28 20 10

根据策略,三种物品单位重量价值一样,程序无法依据现有策略作出判断,如果选择A,则答案错误。

值得注意的是,贪心算法并不是完全不可以使用,贪心策略一旦经过证明成立后,它就是一种高效的算法。比如,求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。

public class Greedy { 
		public static void main(String[] args) { 
			Scanner in = new Scanner(System. in); 
			System. out. println("Please enter the number of objects(请输入物品 的 数量: ) ") ;
			int n = in. nextInt() ;
			int[] w = new int[n];//物品重量数组 
			weight int[] v = new int[n]; //物品价值数组 value 
			System. out. println("Now please enter the weight of the objects(现在请输入这些物品的重量: ) ") ;
			for(int i=0; i<n; i++) {
				w[i] = in. nextInt() ; 
			} 
			System. out. println("Now please enter the value of the ojects(现在请输入这些物品的价值: ) ") ;
			for(int j=0; j<n; j++) {
				v[j] = in. nextInt() ; 
			} 
			System. out. println("Now please enter the capacity of the pack(请输入背包的容积: ) ") ;
			int c = in. nextInt() ;
			double startTime = System. currentTimeMillis() ;
			int[] index = new int[n]; 
			double[] r = new double[n]; //定义物品的质量价值 
			for(int k=0; k<n; k++) { 
				r[k] = v[k]/w[k]; //获取物品的重量价值 index[k] = k;
			} 
			//采用选择排序的方法来求解 
			double temp = 0;
			int x = 0; 
			for(int i=0; i<n-1; i++) { 
				for(int j=i+1; j<n;j++) { 
					if(r[i]<r[j]) { 
						temp = r[i]; 
						r[i] = r[j]; 
						r[j] = temp; 
						x = index[i]; 
						index[i] = index[j]; i
						ndex[j] = x; 
					} 
				} 
			} 
			//将排序后的重量和价值存放在新的数组中 
			int[] w1 = new int[n]; 
			int[] v1 = new int[n]; 
			for(int i=0; i<n; i++) { 
				v1[i] = v[index[i]]; 
				w1[i] = w[index[i]]; 
			} 
			//初始化解向量 
			int[] x1 = new int[n]; 
			for (int i = 0; i < n; i++) {
				x1[i] = 0; 
			} 
			/* * 求解并打印向量 */ 
			for(int i=0; i<n; i++) {
				if(w1[i]<c) { 
					x1[i] = 1; c = c-w1[i]; 
				} 
			} 
			System. out. println("The solution vector is(解向量是: ) "+Arrays. toString(x1) ) ;
			/* * 根据解向量求出最大价值并打印出来 */ 
			int maxValue=0; for(int i=0; i<n; i++) { 
				if(x1[i]==1) { 
					maxValue = maxValue+v1[i]; 
				} 
			} 
			System. out. println("Now, the max value of object in the pack is(背包可以容纳的最大价值是: ) "+maxValue) ;
			//算法结束时间 
			double endTime = System. currentTimeMillis() ; 
			System. out. println("The Statements takes the time is(算法执行所花费的时间为: ) "+(endTime-startTime) + " milliseconds!") ; } }
			}
		}
	}

}

均分纸牌问题]有N堆纸牌,编号分别为1,2,…,n。每堆上有若干张,但纸牌总数必为n的倍数.可以在任一堆上取若干张纸牌,然后移动。移牌的规则为:在编号为1上取的纸牌,只能移到编号为2的堆上;在编号为n的堆上取的纸牌,只能移到编号为n-1的堆上;其他堆上取的纸牌,可以移到相邻左边或右边的堆上。现在要求找出一种移动方法,用最少的移动次数使每堆上纸牌数都一样多。例如:n=4,4堆纸牌分别为:① 9 ② 8 ③ 17 ④ 6 移动三次可以达到目的:从③取4张牌放到④ 再从③区3张放到②然后从②去1张放到①。

输入输出样例:4

9 8 17 6

屏幕显示:3

算法分析:设a[i]为第I堆纸牌的张数(0<=I<=n),v为均分后每堆纸牌的张数,s为最小移动次数。

我们用贪心算法,按照从左到右的顺序移动纸牌。如第I堆的纸牌数不等于平均值,则移动一次(即s加1),分两种情况移动:

1.若a[i]>v,则将a[i]-v张从第I堆移动到第I+1堆;

2.若a[i]<v,则将v-a[i]张从第I+1堆移动到第I堆。

为了设计的方便,我们把这两种情况统一看作是将a[i]-v从第I堆移动到第I+1堆,移动后有a[i]=v; a[I+1]=a[I+1]+a[i]-v.

在从第I+1堆取出纸牌补充第I堆的过程中可能回出现第I+1堆的纸牌小于零的情况。

如n=3,三堆指派数为1 2 27 ,这时v=10,为了使第一堆为10,要从第二堆移9张到第一堆,而第二堆只有2张可以移,这是不是意味着刚才使用贪心法是错误的呢?

我们继续按规则分析移牌过程,从第二堆移出9张到第一堆后,第一堆有10张,第二堆剩下-7张,在从第三堆移动17张到第二堆,刚好三堆纸牌都是10,最后结果是对的,我们在移动过程中,只是改变了移动的顺序,而移动次数不便,因此此题使用贪心法可行的。

Java源程序:

public class Greedy {
    public static void main(String[] args) {
  int n = 0, avg =0, s = 0;
  Scanner scanner = new Scanner(System.in);
  ArrayList<Integer> array = new ArrayList<Integer>();
  System.out.println("Please input the number of heaps:");
  n = scanner.nextInt();
  System.out.println("Please input heap number:");
  for (int i = 0; i < n; i++) {
   array.add(scanner.nextInt());
  }
  for(int i = 0; i < array.size(); i ++){
   avg += array.get(i);
  }
  avg = avg/array.size();
  System.out.println(array.size());
  System.out.println(avg);
  for(int i = 0; i < array.size()-1; i ++){
   s++;
   array.set(i+1, array.get(i+1)+array.get(i)-avg);   
  }
  System.out.println("s:" + s);
 }
}

利用贪心算法解题,需要解决两个问题:

一是问题是否适合用贪心法求解。我们看一个找币的例子,如果一个货币系统有三种币值,面值分别为一角、五分和一分,求最小找币数时,可以用贪心法求解;如果将这三种币值改为一角一分、五分和一分,就不能使用贪心法求解。用贪心法解题很方便,但它的适用范围很小,判断一个问题是否适合用贪心法求解,目前还没有一个通用的方法,在信息学竞赛中,需要凭个人的经验来判断。

二是确定了可以用贪心算法之后,如何选择一个贪心标准,才能保证得到问题的最优解。在选择贪心标准时,我们要对所选的贪心标准进行验证才能使用,不要被表面上看似正确的贪心标准所迷惑,如下面的例子。

最大整数问题]设有n个正整数,将它们连接成一排,组成一个最大的多位整数。

例如:n=3时,3个整数13,312,343,连成的最大整数为34331213。

又如:n=4时,4个整数7,13,4,246,连成的最大整数为7424613。

输入:n

N个数

输出:连成的多位数

算法分析:此题很容易想到使用贪心法,在考试时有很多同学把整数按从大到小的顺序连接起来,测试题目的例子也都符合,但最后测试的结果却不全对。按这种标准,我们很容易找到反例:12,121应该组成12121而非12112,那么是不是相互包含的时候就从小到大呢?也不一定,如12,123就是12312而非12123,这种情况就有很多种了。是不是此题不能用贪心法呢?

其实此题可以用贪心法来求解,只是刚才的标准不对,正确的标准是:先把整数转换成字符串,然后在比较a+b和b+a,如果a+b>=b+a,就把a排在b的前面,反之则把a排在b的后面。

java源程序:

public static void main(String[] args){
  String str = "";
  ArrayList<String> array = new ArrayList<String>();
  Scanner in = new Scanner(System.in);
  System.out.println("Please input the number of data:");
  int n = in.nextInt();
  System.out.println("Please input the data:");
  while (n-- > 0) {
   array.add(in.next());   
  }
  for(int i = 0; i < array.size(); i ++)
   for(int j = i + 1; j < array.size(); j ++){
    if((array.get(i) + array.get(j)).compareTo(array.get(j) + array.get(i)) < 0){
     String temp = array.get(i);
     array.set(i, array.get(j));
     array.set(j, temp);
    }
   }  
  for(int i = 0; i < array.size(); i ++){
   str += array.get(i);
  }
  System.out.println("str=:"+str);  
 }
}

[活动安排问题] 活动安排问题是可以用贪心算法有效求解的一个很好的例子。该问题要求高效地安排一系列争用某一公共资源的活动。贪心算法提供了一个简单、漂亮的方法使得尽可能多的活动能兼容地使用公共资源。

设有n个活动的集合e={1,2,…,n},其中每个活动都要求使用同一资源,如演讲会场等,而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si< fi。如果选择了活动i,则它在半开时间区间[si,fi]内占用资源。若区间[si,fi]与区间[sj,fj]不相交,则称活动i与活动j是相容的。也就是说,当si≥fi或sj≥fj时,活动i与活动j相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

在下面所给出的解活动安排问题的贪心算法gpeedyselector中,各活动的起始时间和结束时间存储于数组s和f{中且按结束时间的非减序:.f1≤f2≤…≤fn排列。如果所给出的活动未按此序排列,我们可以用o(nlogn)的时间将它重排。

/**
 * 活动时间安排
 */
@Test
public void testArrangeActivity() {
    int[] start = {1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12};
    int[] end = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
    List<Integer> results = arrangeActivity(start, end);
    for (int i = 0; i < results.size(); i++) {
        int index = results.get(i);
        System.out.println("开始时间:" + start[index] + ",结束时间:" + end[index]);
    }
}

/**
 * 活动安排
 *
 * @param s 开始时间
 * @param e 结束时间
 * @return
 */
public List<Integer> arrangeActivity(int[] s, int[] e) {
    int total = s.length;
    int endFlag = e[0];
    List<Integer> results = new ArrayList<>();
    results.add(0);
    for (int i = 0; i < total; i++) {
        if (s[i] > endFlag) {
            results.add(i);
            endFlag = e[i];
        }
    }
    return results;
}

[找零钱问题]假如老板要找给我99分钱,他有上面的面值分别为25,10,5,1的硬币数,为了找给我最少的硬币数,那么他是不是该这样找呢,先看看该找多少个25分的,诶99/25=3,好像是3个,要是4个的话,我们还得再给老板一个1分的,我不干,那么老板只能给我3个25分的拉,由于还少给我24,所以还得给我2个10分的和4个1分。

@Test
public void testGiveMoney() {
    //找零钱
    int[] m = {25, 10, 5, 1};
    int target = 99;
    int[] results = giveMoney(m, target);
    System.out.println(target + "的找钱方案:");
    for (int i = 0; i < results.length; i++) {
        System.out.println(results[i] + "枚" + m[i] + "面值");
    }
}

public int[] giveMoney(int[] m, int target) {
    int k = m.length;
    int[] num = new int[k];
    for (int i = 0; i < k; i++) {
        num[i] = target / m[i];
        target = target % m[i];
    }
    return num;
}
    原文作者:贪心算法
    原文地址: https://blog.csdn.net/XxxxWwwwAaaa/article/details/82932464
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞