求解一道贪心算法

因为这个问题涉及到高维求解（大于3维），所以不推荐你用贪心算法或遗传算法之类的算法。这里给出一种升级的蒙特卡罗算法——自适应序贯数论算法，这是一种以GLP集合为基础的随机遍历算法，可以很轻易的解决一系列的高维求解问题，目前根据网上能找到的资料最多可以做到18维。

专注于为中小企业提供做网站、网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业雁山免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千多家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

下面就根据你给出的例子讲解一下：

对于6000的料来说

1185最多做到5根（要求4根，所以一根木料对于1185的产品来说最多有0到45种可能）；1079最多做到5根；985最多做到6根；756最多做到7根。

所以第一次加工一根木料最多有5*6*7*8=1680种加工可能（当然其中包括那些产品总长度大于料长的可能，但是我们可以通过罚函数来避免这些情况），那么利用GLP算法我们可以一次性产生这1680种可能，然后逐个比较那种可能最省木料；

设第一加工出的产品量分别为1 1 3 1

那么1185加工量剩3，1079剩5，985剩7，756剩7，所以第二次加工的可能性有（3+1）*（5+1）*（6+1）*（7+1）=1120种

关于自适应序贯数论算法，根据这道题你可以这样理解，4种尺寸构成了一个4维的空间，四种尺寸的每一种组合相当于空间中的一个点（1185的1根，1079的1根，985的3根，756的1根，这就组成了这个4维空间中的(1,1,3,1)点) ，自适应序贯数论算法就是先根据GLP算法在这个4维空间中随机的，均匀的分布一定的点（也就是尺寸的组合），然后根据目标函数确定其中哪一个点是最优点，我们认为最优点的附近出现最优解的可能性最大，那么我们就以最优点为中心，以一定的尺度为半径将原空间缩小，然后我们在心空间中再一次利用GLP算法均匀，随机的充满这个空间，然后重复以上过程，直到这个空间小到我们事先规定的大小，这样我们就找到了最优解。

也许你会担心算法一上来就收敛到了局部最优解，然后一直在这里打转，不用担心，GLP最大的优点就是均匀的充斥整个空间，尽量将每一种可能都遍历到。

这种算法的缺点在于充斥空间用的点需要生成向量来生成，每一种充斥方式都需要不同的向量，你可以在《数论方法在统计中的应用》这本书中查到已有的每种充斥方式对应的那些生成向量。

下面是我跟据对你给出的例子的理解算出的结果。

1185:1根

1079:1根

985:3根

756:1根

剩余木料0

1185:1根

1079:1根

985:3根

756:1根

剩余木料0

1185:1根

1079:1根

985:3根

756:1根

剩余木料0

1185:1根

1079:0根

985:1根

756:5根

剩余木料15

1185:0根

1079:3根

985:0根

756:0根

剩余木料2748

用去木料：5根

请按任意键继续. . .

程序代码如下：（变量都是用汉语拼音标的）

#include stdlib.h

#include stdio.h

#include math.h

#include iostream.h

#include iomanip.h

#include time.h

#include fstream.h

#include windows.h

#include "glp.h"

#define jiedeweishu 4

#define glpgeshu 10007

#define glpgeshu1 5003//100063

#define glpgeshu2 6007//33139//71053//172155//100063

#define yuanmuchang 6000

#define qiegesushi 5

#define chicun1 1185

#define chicun2 1079

#define chicun3 985

#define chicun4 756

#define chicun1shuliang 4

#define chicun2shuliang 6

#define chicun3shuliang 10

#define chicun4shuliang 8

float xuqiuchicun[jiedeweishu]={chicun1,chicun2,chicun3,chicun4};

float chicunxuqiuliang[jiedeweishu]={chicun1shuliang,chicun2shuliang,chicun3shuliang,chicun4shuliang};

float zuobianjie0[jiedeweishu];//{-19,1,-11,1.5,0,200};//{0.39111,-18.5,1,-11,1,0,2};//左边界

float youbianjie0[jiedeweishu];//{-17,1.5,-7,2,0.05,900};//{0.393,-17,2,-9,2,0.1,6};//右边界

float zuobianjie[jiedeweishu];

float youbianjie[jiedeweishu];

float zuobianjie1[jiedeweishu];//过度用

float youbianjie1[jiedeweishu];

float zuobianjie2[jiedeweishu];//局部边界

float youbianjie2[jiedeweishu];

float zuobianjie3[jiedeweishu];//大边界

float youbianjie3[jiedeweishu];

float sheng_cheng_xiang_liang[jiedeweishu]={1,1206,3421,2842};//生成向量

float sheng_cheng_xiang_liang1[jiedeweishu]={1,792,1889,191};//{1,39040,62047,89839,6347,30892,64404};//生成向量

float sheng_cheng_xiang_liang2[jiedeweishu]={1,1351,5080,3086};//{1,18236,1831,19143,5522,22910};//{1,18010,3155,50203,6065,13328};//{1,167459,153499,130657,99554,61040,18165};

struct chushi

{

float geti[jiedeweishu];

float shiyingdu;

};

chushi *zuiyougeti;//精英保存策略

chushi *zuiyougetijicunqi;

int sishewuru(float);

float chazhi;//左右边界的差

int biaozhi;//判断寻优是否成功1表示成功0表示不成功

int maxgen;//最大计算代数

int gen;//目前代数

void initialize();//算法初始化

void jingyingbaoliu();//精英保存的实现

void mubiaohanshu1(chushi bianliang);//适应度的计算使用残差法

int cmpshiyingdujiang(const void *p1,const void *p2)

{

float i=((chushi *)p1)-shiyingdu;

float j=((chushi *)p2)-shiyingdu;

return ij ? 1:(i==j ? 0:-1);//现在是按降序牌排列，将1和-1互换后就是按升序排列

}

int cmp1(const void *p1,const void *p2)

{

float i= *(float*)p1;

float j= *(float*)p2;

return ij ? 1:(i==j ? 0:-1);//现在是按降序牌排列，将1和-1互换后就是按升序排列

}

void main()

{

float bianjiebianhuashuzu[jiedeweishu];

float yiwanchengshuliang[jiedeweishu];

zuiyougeti=new chushi;//最优个体的生成

zuiyougetijicunqi=new chushi;

int i;

for(i=0;ijiedeweishu;i++)

{

zuiyougeti-geti[i]=0;

yiwanchengshuliang[i]=0;

}

int muliaoshuliang=0;

while(1)

{

if(yiwanchengshuliang[0]==chicun1shuliangyiwanchengshuliang[1]==chicun2shuliangyiwanchengshuliang[2]==chicun3shuliangyiwanchengshuliang[3]==chicun4shuliang)

break;//都加工完了就退出程序

biaozhi=1;

for(i=0;ijiedeweishu;i++)

{

bianjiebianhuashuzu[i]=chicunxuqiuliang[i]-yiwanchengshuliang[i];

}

for(i=0;ijiedeweishu;i++)

{

zuobianjie0[i]=0;

if(bianjiebianhuashuzu[i](int)(yuanmuchang/xuqiuchicun[i]))

{

youbianjie0[i]=(int)(yuanmuchang/xuqiuchicun[i]);

}

else

{

youbianjie0[i]=bianjiebianhuashuzu[i];

}

}

for(i=0;ijiedeweishu;i++)

{

zuobianjie[i]=zuobianjie0[i];

youbianjie[i]=youbianjie0[i];

}

for(i=0;ijiedeweishu;i++)//在这套程序中边界分为两个部分,其中一组是根据最优解的收敛范围进行局部寻优,如果在局部找不到最优解则以现有最优解为中心进行全局搜索

{

zuobianjie2[i]=zuobianjie[i];

youbianjie2[i]=youbianjie[i];

zuobianjie3[i]=zuobianjie[i];

youbianjie3[i]=youbianjie[i];

}

zuiyougeti-shiyingdu=-3000;

//cout zuiyougeti-shiyingduendl;

initialize();

//for(i=0;ijiedeweishu;i++)/////

//{////

// coutzuiyougeti-geti[i]",";////

//}/////////

//coutendl;/////

// cout"初始最优解："" "-zuiyougeti-shiyingduendl;/////////////

for(gen=1;genmaxgen;gen++)

{

jingyingbaoliu();

if(chazhi1e-1)

break;

}

//cout"最终在收敛的范围内左右边界的最大差值: "chazhiendl;

//for(i=0;ijiedeweishu;i++)

//{

// coutsetiosflags(ios::fixed)setprecision(6)zuiyougeti-geti[i]",";

// }

//coutendl;

//cout"共用代数"genendl;

cout"1185:"zuiyougeti-geti[0]"根"endl;

cout"1079:"zuiyougeti-geti[1]"根"endl;

cout"985:"zuiyougeti-geti[2]"根"endl;

cout"756:"zuiyougeti-geti[3]"根"endl;

cout"剩余木料"(-zuiyougeti-shiyingdu)endl;////////////////

coutendl;

for(i=0;ijiedeweishu;i++)

{

yiwanchengshuliang[i]=yiwanchengshuliang[i]+zuiyougeti-geti[i];

}

muliaoshuliang++;

}

cout"用去木料："muliaoshuliang"根"endl;

delete [] zuiyougetijicunqi;

delete [] zuiyougeti;

system("pause");

}

void initialize()

{

maxgen=20;//最大代数

gen=0;//起始代

chazhi=100;

chushi *chushizhongqunji;

chushizhongqunji=new chushi[glpgeshu];

int i,j;

for(i=0;ijiedeweishu;i++)

{

zuobianjie1[i]=zuobianjie[i];

youbianjie1[i]=youbianjie[i];

}

float **glp_shu_zu;//第一次求解，为了使解更精确这一次求解需要的点最多

glp_shu_zu=new (float *[glpgeshu]);

for(i=0;iglpgeshu;i++)

{

glp_shu_zu[i]=new float[jiedeweishu];//生成的glp向量用glp_shu_zu储存

}

glp glp_qiu_jie_first(glpgeshu,jiedeweishu);//定义生成多少组glp向量和向量的维数

glp_qiu_jie_first.glp_qiu_jie(glp_shu_zu,sheng_cheng_xiang_liang);//将生成的glp向量用glp_shu_zu储存，同时将生成向量带入glp类

for(i=0;iglpgeshu;i++)//产生初始种群

{

for(j=0;jjiedeweishu;j++)

{

chushizhongqunji[i].geti[j]=sishewuru((zuobianjie[j]+(youbianjie[j]-(zuobianjie[j]))*glp_shu_zu[i][j]));

if(j==3glp_shu_zu[i][j]0)

{

cout"274"endl;/////////////

coutzuobianjie[j]" "glp_shu_zu[i][j]" "youbianjie[j]endl;////////////////////

system("pause");///////////////////

}

}

}

for(i=0;iglpgeshu;i++)//计算初始种群的适应度

{

mubiaohanshu1(chushizhongqunji[i]);

}

qsort(chushizhongqunji,glpgeshu,sizeof(chushi),cmpshiyingdujiang);//根据适应度将初始种群集按降序进行排列

chushi *youxiugetiku;//建立一个储存优秀个体的库

youxiugetiku=new chushi[glpgeshu];//建立一个储存优秀个体的库

int jishuqi=0;

i=0;

while(chushizhongqunji[i].shiyingduzuiyougeti-shiyingdu)//凡是比上一代的最优个体还要好的个体都放入优秀个体库

{

for(int j=0;jjiedeweishu;j++)

{

youxiugetiku[i].geti[j]=chushizhongqunji[i].geti[j];

//coutyouxiugetiku[i].geti[j]endl;

}

//system("pause");

i++;

}

// coutiendl;//////////////

//system("pause");//////////////////////////////////////

jishuqi=i;//将得到的优秀个体的数量放入jishuqi保存

float *bianjiezancunqi;//下面就要以优秀个体库中个体的范围在成立一个局部搜索区域，所以先建立一个边界暂存器

bianjiezancunqi=new float[jishuqi];

for(i=0;ijiedeweishu;i++)

{

for(int j=0;jjishuqi;j++)

{

bianjiezancunqi[j]=youxiugetiku[j].geti[i];//将优秀个体库每一维的数据都放入bianjiezancunqi

}

qsort(bianjiezancunqi,jishuqi,sizeof(float),cmp1);//对这些数据按降序排列，取两个边界又得到一个局部范围

//将得到的范围进行保存

zuobianjie[i]=bianjiezancunqi[jishuqi-1];

youbianjie[i]=bianjiezancunqi[0];

//coutzuobianjie[i]endl;//////////////////////////

// coutyoubianjie[i]endl;///////////////////////////

//coutendl;///////////////////

//

if(zuobianjie[i]zuobianjie2[i])//如果新得到的局部左边界在上一代局部左边界左边，则左边界取上一代的

{

zuobianjie[i]=zuobianjie2[i];

}

if(youbianjie[i]youbianjie2[i])//如果新得到的局部右边界在上一代局部右边界右边，则右边界取上一代的

{

youbianjie[i]=youbianjie2[i];

}

}

if(chushizhongqunji[0].shiyingduzuiyougeti-shiyingdu)//本代种群的最优个体比历史最有个个体好，则用本代的代替之，并将标志位赋值为1表示寻优成功

{

for(i=0;ijiedeweishu;i++)

{

zuiyougeti-geti[i]=chushizhongqunji[0].geti[i];

}

zuiyougeti-shiyingdu=chushizhongqunji[0].shiyingdu;

biaozhi=1;

}

delete [] bianjiezancunqi;

delete [] youxiugetiku;

for(i=0;iglpgeshu;i++)

{

delete [] glp_shu_zu[i];

}

delete [] glp_shu_zu;

delete [] chushizhongqunji;

}

void jingyingbaoliu() //精英保留的实现

{

float glpshuliang,xiangliang[jiedeweishu];

if(biaozhi==1)//如果寻优成功则利用局部搜索的数据

{

glpshuliang=glpgeshu1;

for(int i=0;ijiedeweishu;i++)

{

xiangliang[i]=sheng_cheng_xiang_liang1[i];

}

}

else//否则利用全局搜索的数据

{

glpshuliang=glpgeshu2;

for(int i=0;ijiedeweishu;i++)

{

xiangliang[i]=sheng_cheng_xiang_liang2[i];

}

}

chushi *chushizhongqunji;//建立一个用来储存种群的容器

chushizhongqunji=new chushi[glpshuliang];

int i,j;

float **glp_shu_zu;//生成一个glp数组

glp_shu_zu=new (float *[glpshuliang]);

for(i=0;iglpshuliang;i++)

{

glp_shu_zu[i]=new float[jiedeweishu];//生成的glp向量用glp_shu_zu储存

}

glp glp_qiu_jie_first(glpshuliang,jiedeweishu);//定义生成多少组glp向量和向量的维数

glp_qiu_jie_first.glp_qiu_jie(glp_shu_zu,xiangliang);//将生成的glp向量用glp_shu_zu储存，同时将生成向量带入glp类

//cout"377"endl;

if(biaozhi!=1)//如果寻优不成功则进入全局搜索

{

//cout"380"endl;////////////

float bianjiecha[jiedeweishu];

for(i=0;ijiedeweishu;i++)

{

bianjiecha[i]=youbianjie3[i]-zuobianjie3[i];//计算上一代全局每一维范围的宽度

}

static float rou=0.9;//定义收缩比

//float rou=pow(0.5,gen);

for(i=0;ijiedeweishu;i++)//确定新的范围

{

zuobianjie1[i]=zuiyougeti-geti[i]-rou*bianjiecha[i];//左边界为以最优个体为中心-范围宽度乘以收缩比

if(zuobianjie1[i]zuobianjie2[i])//如果新的左边界比目前局部左边界大，那么以目前的为全局寻优的左边界

{

zuobianjie[i]=zuobianjie1[i];

zuobianjie3[i]=zuobianjie1[i];

}

else//否则以局部左边界为全局左边界

{

zuobianjie[i]=zuobianjie2[i];

zuobianjie3[i]=zuobianjie2[i];

}

youbianjie1[i]=zuiyougeti-geti[i]+rou*bianjiecha[i];//右边界为以最优个体为中心+范围宽度乘以收缩比

if(youbianjie1[i]youbianjie2[i])

{

youbianjie[i]=youbianjie1[i];

youbianjie3[i]=youbianjie1[i];

}

else

{

youbianjie[i]=youbianjie2[i];

youbianjie3[i]=youbianjie2[i];

}

}

qsort(bianjiecha,jiedeweishu,sizeof(float),cmp1);

if(chazhi==bianjiecha[0])//如果最大边界差不变的话就将收缩因子变小

{

rou=pow(rou,2);

}

chazhi=bianjiecha[0];

}

//cout"421"endl;/////////////////////

for(i=0;iglpshuliang;i++)//根据新产生的最优个体确定glp群

{

for(j=0;jjiedeweishu;j++)

{

chushizhongqunji[i].geti[j]=sishewuru((zuobianjie[j]+(youbianjie[j]-(zuobianjie[j]))*glp_shu_zu[i][j]));

}

}

for(i=0;iglpshuliang;i++)

{

mubiaohanshu1(chushizhongqunji[i]);

}

qsort(chushizhongqunji,glpshuliang,sizeof(chushi),cmpshiyingdujiang);

zuiyougetijicunqi-shiyingdu=zuiyougeti-shiyingdu;

if(chushizhongqunji[0].shiyingduzuiyougeti-shiyingdu)

{

for(i=0;ijiedeweishu;i++)

{

zuiyougeti-geti[i]=chushizhongqunji[0].geti[i];

}

zuiyougeti-shiyingdu=chushizhongqunji[0].shiyingdu;

biaozhi=1;

}

else

{

// cout"446"endl;/////////////

biaozhi=0;

}

if(biaozhi==1)//如果寻优成功了就需要确立一个新的局部最优解范围

{

chushi *youxiugetiku;

youxiugetiku=new chushi[glpshuliang];

int jishuqi=0;

i=0;

while(chushizhongqunji[i].shiyingduzuiyougetijicunqi-shiyingdu)

{

for(int j=0;jjiedeweishu;j++)

{

youxiugetiku[i].geti[j]=chushizhongqunji[i].geti[j];

}

i++;

}

jishuqi=i;

float *bianjiezancunqi;

bianjiezancunqi=new float[jishuqi];

for(i=0;ijiedeweishu;i++)

{

for(int j=0;jjishuqi;j++)

{

bianjiezancunqi[j]=youxiugetiku[j].geti[i];

}

qsort(bianjiezancunqi,jishuqi,sizeof(float),cmp1);

zuobianjie[i]=bianjiezancunqi[jishuqi-1];

youbianjie[i]=bianjiezancunqi[0];

// coutzuobianjie[i]endl;//////////////

// coutyoubianjie[i]endl;/////////////

// coutendl;///////////////

if(zuobianjie[i]zuobianjie2[i])

{

zuobianjie[i]=zuobianjie2[i];

}

if(youbianjie[i]youbianjie2[i])

{

youbianjie[i]=youbianjie2[i];

}

}

delete [] bianjiezancunqi;

delete [] youxiugetiku;

}

for(i=0;iglpshuliang;i++)

{

delete [] glp_shu_zu[i];

}

delete [] glp_shu_zu;

delete [] chushizhongqunji;

}

void mubiaohanshu1(chushi bianliang)//计算shiyingdu

{

int i=0;

int sunshi,chanpin;

sunshi=qiegesushi*(bianliang.geti[0]+bianliang.geti[1]+bianliang.geti[2]+bianliang.geti[3]-1);

chanpin=chicun1*bianliang.geti[0]+chicun2*bianliang.geti[1]+chicun3*bianliang.geti[2]+chicun4*bianliang.geti[3];

bianliang.shiyingdu=yuanmuchang-sunshi-chanpin;

if(bianliang.shiyingdu!=0)//如果不能正好将木料分成所需尺寸则要多切一刀

{

sunshi=qiegesushi*(bianliang.geti[0]+bianliang.geti[1]+bianliang.geti[2]+bianliang.geti[3]);

}

if(bianliang.shiyingdu0)//罚函数

{

bianliang.shiyingdu=bianliang.shiyingdu+1e5;

}

bianliang.shiyingdu=-bianliang.shiyingdu;

}

int sishewuru(float x)

{

float y;

int z;

y=x-(int)x;

if(y0.5)

{

z=(int)(x);

}

else

{

z=(int)x;

z=z+1;

}

return z;

}

glp.h源文件贴不下了，把你邮箱给我我发给你

邮箱：hu_hu605@163.com

找零钱问题 [贪心算法](java实现）

public getMin{

public int MinNumber=0;

public int findMax(int[] a){

for(int i=0;ia.length;i++){

if(a[i]==0) return a[--i];

}

return a[a.length-1];

}

public boolean Compare(int a,int b){

public boolean flag=true;

if(ab) flag=flase;

return flag;

}

public int getMinNumber(int[] M,int Money){

int[] findM=new int[M.length];

int index=0;

for(int i=0;iM.length;i++){

boolean f = this.Compare(M[i],money)

if(f) findM[index++]=M[i];

}

int max = this.findMax(findM);

MinNumber++;

if((Money-max)!=0) {

getMinNumber(M,Money-max)

}

return MinNumber;

}

public int[] Start(){

System.out.println("请输入查询组数");

int group=System.in.read();

int[] M={1,2,5,10,20,50,100};

int[] Result = new Int[group];

int index=0;

while (group-- 0){

System.out.println("请输入金额");

int money=System.in.read();

Result[index++] = getMinNumber(M,money);

MinNumber=0;

}

}

public void print(int[] MinNumber){

for(int i=0;iMinNumber.length.i++){

System.out.println(MinNumber[i]+" ");

}

}

}

public static void main(String[] args){

new getMin().print(new getMin().Start());

}

没测试啊，有问题请勿喷，呵呵

JAVA-数组转化问题

public class test6 {

int a[] = { 1, 2, 3, 4, 5, 6, 7 };

int b[] = { 2, 1, 4, 3, 6, 5, 7 };

public static void main(String args[]) {

test6 test = new test6();

test.go();

}

public void go() {

if (smart(a, b))

System.out.println("n=" + n(a, b));

}

public boolean smart(int[] a, int[] b) {

int a_[] = array(a);

int b_[] = array(b);

if (a.length == b.length) {

for (int c = 0; c a.length; c++) {

if (a_[c] != b_[c]) {

System.out.println("cannot transform");

return false;

}

}

for (int c = 0; c a.length; c++)

System.out.print(a[c]+" ");

System.out.println();

for (int c = 0; c b.length; c++)

System.out.print(b[c]+" ");

System.out.println();

return true;

} else {

System.out.println("cannot transform");

return false;

}

}

public int[] array(int[] a) {

int[] z = new int[a.length];

for (int c = 0; c a.length; c++)

z[c] = a[c];

for (int c = 0; c z.length - 1; c++) {

for (int d = c + 1; d z.length; d++) {

if (z[c] z[d]) {

int x = z[c];

z[c] = z[d];

z[d] = x;

}

}

}

return z;

}

public int n(int[] a, int[] b) {

int c = 0;

for (int d = 0; d a.length; d++)

if (a[d] != b[d])

c += 5;

return (c + 8) / 10;

}

}

java算法设计问题（贪心算法）

第一、你说的那个东西不叫框架

第二、你用的算法不是多路合并

第三、题目不是让你合并、是让你找出最优解

解答，我晕这题目有啥解答的啊，你不是自己编的吧，假如合并两个有序序列只要m+n-1次比较，那么不单单这两个序列各自有序，同时其中一个序列任意元素大于另外一个序列所有元素

那么答案就是按照k的序号从前想后依次合并啊

java代码，多机调度问题，怎么解释

多机调度问题的Java实现（贪心算法）

具体问题描述以及C/C++实现参见网址

[java] view plain copy print?

import java.util.ArrayList;  

import java.util.Collections;  

import java.util.LinkedList;  

import java.util.List;  

/** 

* 多机调度问题--贪心算法 

* @author Lican 

* 

*/  

public class JobMachine {  

public static class JobNode implements Comparable{  

int id;//作业的标号  

int time;//作业时间  

public JobNode(int id,int time){  

this.id=id;  

this.time=time;  

}  

@Override  

public int compareTo(Object x) {//按时间从大到小排列  

int times=((JobNode)x).time;  

if(timetimes) return -1;  

if(time==times) return 0;  

return 1;  

}         

}  

public static class MachineNode implements Comparable{  

int id;//机器的标号  

int avail;//机器空闲的时间（即机器做完某一项工作的时间）  

public MachineNode(int id,int avail){  

this.id=id;  

this.avail=avail;  

}  

@Override  

public int compareTo(Object o) {//升序排序，LinkedList的first为最小的  

int xs=((MachineNode)o).avail;  

if(availxs) return -1;  

if(avail==xs) return 0;  

return 1;  

}  

}  

public static int greedy(int[] a ,int m){  

int n=a.length-1;//a的下标从1开始，所以n（作业的数目）=a.length-1  

int sum=0;  

if(n=m){  

for(int i=0;in;i++)  

sum+=a[i+1];  

System.out.println("为每个作业分别分配一台机器");  

return sum;  

}  

ListJobNode d=new ArrayListJobNode();//d保存所有的作业  

for(int i=0;in;i++){//将所有的作业存入List中，每一项包含标号和时间  

JobNode jb=new JobNode(i+1,a[i+1]);  

d.add(jb);  

}  

Collections.sort(d);//对作业的List进行排序  

LinkedListMachineNode h=new LinkedListMachineNode();//h保存所有的机器  

for(int i=1;i=m;i++){//将所有的机器存入LinkedList中  

MachineNode x=new MachineNode(i,0);//初始时，每台机器的空闲时间（完成上一个作业的时间）都为0  

h.add(x);  

}  

int test=h.size();  

for(int i=0;in;i++){  

Collections.sort(h);  

MachineNode x=h.peek();  

System.out.println("将机器"+x.id+"从"+x.avail+"到"+(x.avail+d.get(i).time)+"的时间段分配给作业"+d.get(i).id);  

x.avail+=d.get(i).time;  

sum=x.avail;  

}  

return sum;  

}  

public static void main(String[] args) {  

int[] a={0,2,14,4,16,6,5,3};  

int m=3;  

int sum=greedy(a,m);  

System.out.println("总时间为："+sum);  

}  

}  

/** 

运行结果： 

将机器1从0到16的时间段分配给作业4 

将机器2从0到14的时间段分配给作业2 

将机器3从0到6的时间段分配给作业5 

将机器3从6到11的时间段分配给作业6 

将机器3从11到15的时间段分配给作业3 

将机器2从14到17的时间段分配给作业7 

将机器3从15到17的时间段分配给作业1 

总时间为：17 

*/

如何用Java语言编程实现下面这道题？

贪心算法: 思路就是对花到第一个喷泉距离从近到远排序，然后找到另一个喷泉距离最大的一个

复杂度O(n^2)。

import java.util.*;

public class Demo {

static long[][] flowers;

public static void main(String[] args) {

Scanner in=new Scanner(System.in);

int n=in.nextInt();

int x1=in.nextInt();

int y1=in.nextInt();

int x2=in.nextInt();

int y2=in.nextInt();

flowers=new long[n][2];

for (int i = 0; i n; i++) {

int x=in.nextInt();

int y=in.nextInt();

flowers[i][0]=dis(x,y,x1,y1);

flowers[i][1]=dis(x,y,x2,y2);

}

Arrays.sort(flowers, (o1, o2) - {

if (o1[0]o2[0])

return -1;

else if (o1[0]==o2[0])

return 0;

else return 1;

});

long temp=0;

long temp2=0;

for (int i = 0; i flowers.length; i++) {

temp=Math.max(temp,flowers[i][1]);

}

for (int i = 0; i flowers.length; i++) {

for (int j = i+1; j flowers.length ; j++) {

if (flowers[j][1]temp2)

temp2=flowers[j][1];

}

temp=Math.min(temp,flowers[i][0]+temp2);

temp2=0;

}

System.out.println(temp);

}

public static long dis(int x,int y,int x1,int y1){

return (long) (x1 - x) *(x1-x)+ (long) (y1 - y) *(y1-y);

}

}

当前文章：贪心算法java代码 贪心算法Java
地址分享：http://myzitong.com/article/hpdcic.html