数据结构之贪心算法（背包问题的思考）-（十）

package com.lip.datastructure;
/**
*贪心算法：装箱问题的思考
* @author Lip
*装箱问题可以是时间调问题的延伸，当一个箱子没有容积限制，那么就是时间调度问题
*在时间调度问题中：存在两个可以讨论的问题。1.平均最短时间 2.总的最短时间
*这两个问题都和装箱问题中问题如此类似。
*/
/*
* 上面是我理解的装箱问题，本来是想说背包问题的
* 背包问题的描述：有N件物品和一个容量为V的背包。第i件物品的重量是w[i]，价值是v[i]。
* 求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。
*/
/*
* 贪心算法可以解决装箱问题，也可以解决背包问题，但是由贪心算法求出的解的可能不是最优解。
* 如：事实上，作为一个理性人，我们都是贪心的。当你面对一堆金银珠宝的时候，你有一个背包，你的选择肯定会是优先选择性价比最高的珠宝。
* 那么，从这个角度来说，我们可以用贪心算法来解决背包问题，即使不是问题的最优解。但是，这个解却是一个理人人的通常选择的贪心 策略。
*/
public class Pack
{

public static void main(String[] args)
{
/***********************装箱问题********************************/
int []weight={8,7,5,4,4,3,3,2,2,2,1};
int []box={12,12,12,10};
int []result=loadInBox(Type.OFFLINE, box, weight);

for(int i=0;i<box.length;i++)
{
System.out.println("第"+(i+1)+"号箱子货物：");
print(weight, result, i+1);
System.out.println();
}
//				/***********0-1背包问题**************/
//				int []weight={2,3,4,6,2,5,4,3,8,1};
//				int []value={7,8,13,20,17,9,12,15,5,5};
//				int c=20;
//				int []position=loadInPack(c, value, weight);
//				int sum=0;
//				int sumW=0;
//				for(int i=0;i<position.length;i++)
//					{
//						if(position[i]!=0)
//							{
//							  sumW+=weight[position[i]-1];
//							  sum+=value[position[i]-1];
//							  System.out.println(position[i]+"->("+weight[position[i]-1]+","+value[position[i]-1]+")");
//							}
//						else break;
//					}
//				System.out.println("最大的收益为："+sum);
//				System.out.println("有多少空间没有利用："+(c-sumW));

}
/***********************装箱问题********************************/
/**
* @param type
* @param box 箱子
* @param weight 货物重量
* @return
*/
public static int[]loadInBox(Type type,int box[],int []weight)
{
int []result=new int[weight.length];
Sort.quickSort(weight);
int sum=0;
for(int i=0;i<weight.length;i++)
sum+=weight[i];
int sum2=0;//箱子总容积
for(int i=0;i<box.length;i++)
sum2+=box[i];
if(sum>sum2)//艹，箱子不够
return null;
if(type==Type.OFFLINE)//给每个箱子都分配一个最大的货物
{
for(int i=weight.length-1,j=0;i>-1;i--)
{
int find=box.length;
while(weight[i]>box[j])//不可以装
{
j=(j+1)%box.length;
find--;
if(find==0)//箱子不够
{
System.out.println("------背包不够---------");
return null;
}
}
result[i]=j+1;
box[j]-=weight[i];
j=(j+1)%box.length;
}
}
else if(type==Type.ONLINE)//先装一个箱子
{
for(int i=0;i<box.length;i++)
{
//box[i] 箱子的当前剩余，也就是还可以装的货物
for(int j=weight.length-1;j>-1;j--)//一直装，直到装满
{
if(box[i]==0)//该箱子装满了
break;
if(result[j]==0&&weight[j]<=box[i])//该货物没有被装
{
box[i]-=weight[j];
result[j]=i+1;
}
}
}
}
return result;
}
public static void print(int []weight,int []result,int k)
{
for(int i=0;i<result.length;i++)
if(result[i]==k)
System.out.print(weight[i]+" ");
}
/**
*
* @author Lip
* 解决装箱问题有两种方式，一种是联机，一种是脱机。
* 所谓联机就是将一个箱子完全放满货物后，再开始处理下一个箱子
* 脱机就是将所有的货物都读取进来，按照从大到小的顺序将货物分配给箱子，直到各个箱子都被装满
*/
public enum Type
{
ONLINE,OFFLINE;
};
/**************************0-1背包问题（贪心算法）************************************/
/**
*
* @param c 背包容量
* @param value 每个物品的价值
* @param weight 每个物品的容积
*/
/*
* 当使用贪心算法解决背包问题时，那么考虑到贪心策略，就是要保证当前选择是最好的。
* 那么另外一个参考量“性价比”就被引用，p=value/weight
* 一直选择性价比最高的物品放入到背包中，直至背包被放满
*/
public static int[] loadInPack(int c,int[]value,int []weight)
{

double []price=new double[value.length];//性价比
int []position=new int[value.length];
int p=0;
for(int i=0;i<value.length;i++)
price[i]=(double)value[i]/weight[i];
//开始装了
while(c>0)
{
double max=-1;
int pos=-1;
for(int i=0;i<price.length;i++)//找性价比最高的，且没有被装到背包中的
{
if(price[i]!=-1&&price[i]!=0&&max<price[i])
{
max=price[i];
pos=i;
}
}
if(pos==-1)//虽然剩下空间，但是再也找不到合适的了
break;
if(c>=weight[pos])
{
c-=weight[pos];
price[pos]=-1;//已经装过
position[p]=pos+1;
p++;
}
else
{
price[pos]=0;//装不下，但是可以装比这个更小的
}
}

return position;

}
}