贪心算法：
贪心算法，又称贪婪算法(Greedy Algorithm)，是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优解出发来考虑，它所做出的仅是在某种意义上的局部最优解。贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解。
例子：背包问题
有一个背包，背包容量是W=150。有7个物品，每个物品有各自的重量和价值，每个物品有一件。要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。
物品 A B C D E F G
重量 35 30 60 50 40 10 25
价值 10 40 30 50 35 40 30
贪心算法Java实现：
package com.algorithm.greedy;
import java.util.Arrays;
public class GreedyPackage {
public static void main(String[] args) {
int[] weights={35,30,60,50,40,10,25};
int[] values={10,40,30,50,35,40,30};
int capacity=150;
packageGreedy(capacity,weights,values);
}
private static void packageGreedy(int capacity,int[] weights,int[] values){
int n=weights.length;
double[] r=new double[n];
int[] index=new int[n];//按性价比排序物品的下表
for(int i=0;i<n;i++){
r[i]=(double)values[i]/weights[i];
index[i]=i;//默认排序
}
double temp=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;
int x=index[i];
index[i]=index[j];
index[j]=x;
}
}
}
//排序好的重量和价值分别存到数组中
int[] w1=new int[n];
int[] v1=new int[n];
for(int i=0;i<n;i++){
w1[i]=weights[index[i]];
v1[i]=values[index[i]];
}
int[] x=new int[n];
int maxValue=0;
for(int i=0;i<n;i++){
if(w1[i]<=capacity){
//还可以装得下
x[i]=1;//表示该物品被装下
maxValue+=v1[i];
capacity=capacity-w1[i];
}
}
System.out.println("总共放下的物品数量："+ Arrays.toString(x));
System.out.println("最大价值："+maxValue);
}
}
输出：
总共放下的物品数量：[1, 1, 1, 1, 0, 0, 1]
最大价值：170分治算法：
对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
如果原问题可分割成k个子问题，1<k≤n ，且这些子问题都可解并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。
分治法所能解决的问题一般具有以下几个特征：
1) 该问题的规模缩小到一定的程度就可以容易地解决
2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；
4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。
第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；
第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；
第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。
第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。
例子：八支球队在七天内循环赛日程安排，保证每支球队都要和其他球队进行比赛。
比赛安排如图所示：第一列表示八支球队，第一行表示每支球队在接下来的七天分别跟哪只球队比赛。
分治算法Java实现：
package com.algorithm.dispatch;
/**
* 分治算法
*/
public class SportSchedule {
public static void main(String[] args) {
int n=8;
int[][] t=new int[n][n];
scheduleTable(t,n);
for(int i=0;i<n;i++){
int count=0;
for(int j=0;j<n;j++){
System.out.print(t[i][j]+" ");
count++;
if(count==n){
System.out.println();
}
}
}
}
public static void scheduleTable(int[][] table,int n){
if(n==1){
table[0][0]=1;
}else{
//填充左上区的区域矩阵
int m=n/2;
scheduleTable(table,m);
//填充右上区的区域矩阵
for(int i=0;i<m;i++){
for(int j=m;j<n;j++){
table[i][j]=table[i][j-m]+m;
}
}
//填充左下区的区域矩阵
for(int i=m;i<n;i++){
for(int j=0;j<m;j++){
table[i][j]=table[i-m][j]+m;
}
}
//填充右下区的区域矩阵
for(int i=m;i<n;i++){
for(int j=m;j<n;j++){
table[i][j]=table[i-m][j-m];
}
}
}
}
}
输出：
1 2 3 4 5 6 7 8
2 1 4 3 6 5 8 7
3 4 1 2 7 8 5 6
4 3 2 1 8 7 6 5
5 6 7 8 1 2 3 4
6 5 8 7 2 1 4 3
7 8 5 6 3 4 1 2
8 7 6 5 4 3 2 1