一个止步于64强的小白对于2017年华为挑战赛的总结（java+spfa+最小代价最大流+启发式算法）

因为舍友的邀请，参加了今年华为软件精英挑战赛，最后的成绩也不太理想，没进32强，但还是写个总结在这里吧。。。

没有进入32强意味着我们只做了初赛试题，题目和数据在这里：

http://codecraft.huawei.com/home/detail

题目实际上要求给出一个服务器配置问题。在满足消费者流量需求的前提下，给出花费money最小的流量服务器安置方案。题目中给出了全部网络节点的数目、边的数目和消费节点的数目（文件中第一行数据），每台服务器的价格（第三行数据），和每条链路上的最大流量与单位流量的价格（第5行到第N行的数据），同时也给出了消费节点的编号、与消费节点相连接的网络节点的编号和消费节点的需求流量。

看到的第一眼就觉得这是一个图论的问题，然后再一本算法书上翻了下，觉得最小代价最大流很适合题目，有考虑到时间原因我最终选择了spfa算法。

网上的最小花费最大流大都是针对有向图的，对于无向图就把一条边拆成２条正边，２条反边就好啦～

于是算法流程变成了：

step 1:初始解生成

我们用了最笨的方法，直连消费节点。也就是此时有：

Cost=消费节点数目*服务器的价格

step 2:用基于spfa的minCostmaxFlow算法算出cost

step 3:启发式算法优化

至于启发式算法我原来考虑了这么几个：

模拟退火，蚁群算法，DE算法，遗传算法

很明显，模拟退火算法容易陷入局部最优，但是速度快，其余的更容易达到全局最优，但要求初试的解的数量比较多，也就是说我一次迭代就要算好几个最小费用最大流。后来我发现我的JAVA版最小费用最大流对高级用例只能跑250~300次便放弃了复杂的启发式算法，直接用的模拟退火。。。

如果有人想了解其他的算法，可以看：

http://blog.csdn.net/yezi_1026/article/details/53425072

个人觉得DE挺好的，但很少用于离散的分析问题，其实这个题也类似于整数规划或0-1规划问题，但在DF算法中变异因子F的选取就要看看了。

没有考虑遗传算法，虽然它可以灵巧的用2进制编码处理问题，但是在高维中，遗传算法收敛很慢，甚至是不收敛的。但是也不是不可以用，可以考虑降维，但我的spfa实在是太慢了。。。

关于DE的文章：http://blog.csdn.net/hp910315/article/details/50557042

模拟退火的那段的伪代码如下：

dofire(初试解)
opiter=50000000;//迭代的次数，其实我对于高级用例是用的定时器，这个可以用来处理低中级用例u
preSP=初试解
preSP.check()//这个函数用来检查是否消费节点的需求全部被满足
int iter=0;
{
newSP=changeSpPosition(preSP);
if((preNeed&&nowNeed&&preCost>nowCost)||(!preNeed&&nowNeed))//一定发生替换（）
//如果现在的方案满足所有消费节点的需求，且现在方案的nowCost小，则一定替换
{
替换
if(nowCost<minCost)//目前最优的，则
记录下来
continue;
}else{
if(preNeed&&!nowNeed)//一定不发生替换
{
continue;//不替换
}else{
//按照一定的概率进行替换
int erro=nowCost-preCost;
double r=rand.nextDouble();//随机生成一个双精度型
if(r<Math.exp(-(nowCost-preCost)/T))//如果在这一范围内则替换
{
替换
continue;
}else
{
continue;//不替换
}
}
}
}

至于changeSpPosition(preSP)的函数，也就是实现服务器摆放的函数，我们也是很简单粗暴：

以很小的概率增加服务器

以很大的概率减少服务器数量（尤其是在前期）

以一定概率改变服务器的摆放位置（也就是在已有的服务器上删除一台，在原来非服务器的节点加入一台）

因为我们事先没有对图进行预处理，直接粗暴ＳＰＦＡ导致用例迭代次数不足（尤其是高级用例），再者ＪＡＶＡ本身要比Ｃ＼Ｃ＋＋慢，所以我们又进行了补偿，也就是说，我减少服务器的时候不是一台一台的减少，在前期我可以多台减少，后台再一台一台减少。后来队友又发现，每次删除提供流量最小的服务器会得到较好的结果，于是乎，我们删除的时候总是删除在目前状态中提供流量最小的。。。

源码如下：

有很多备注。。因为我记性不好，呵呵。。。

本身就是小白，所以还望大神指点，尤其是你们怎么能在８５ｓ内跑２万多次ｓｐｆａ的。。。膜拜中。。。

//package com.cacheserverdeploy.deploy
package realcode.ver10;
/*
* 改进之处：对changeSeverMethod()函数的删除操作进行算法上的优化
* */
import java.util.*;

public class Deploy
{
private int nodeNum,edgNum,ServerMoney,CondumerNum;
private int[] subPath;//存储每次从SPFA中的到的路径
private int Inf=99999999;//定义一个无穷大的数
private int[] head,thead,Dis;
private ArrayList<Edge> edge=new ArrayList<Edge>();
private ArrayList<int[]> CPosition=new ArrayList<int[]>();
private int Ss,St,Tb,Ts;//超级源点的位置，超级汇点的位置，超级汇点建立的起始边代号，超级汇点建立的终止边代号
private ArrayList<Edge> eee;//用于做edge的每次变化品
private HashMap<Integer,ArrayList> Adj=new HashMap<Integer,ArrayList>();
private HashMap<Integer,ArrayList> preRoud=new HashMap<Integer,ArrayList>();
private static boolean stop=false;
private static Timer timer=new Timer();//触动定时器，如果到85s则将stop改成true用来终止最优化循环
private ArrayList<Integer> minSP;
private HashMap<Integer,Integer> CPosi=new HashMap<Integer,Integer>();//为了最后转化正确路径的时候迅速
private int Sb,Se;//超级源点建立的起始边代号，超级源点建立的终止边代号
private int minNode,deteNode,minNode2,detIter;//记录删除的时候提供最小流量的节点，和最终删除的节点

public static String[] deployServer(String[] graphContent)
{
/**do your work here**/
Deploy d=new Deploy();
timer.schedule(new MyTask(), 89200);//89200
d.getBasicInformation(graphContent);
return d.changeForm(d.getRealRoud(d.dofire(d.getIntaSeverPosition())));
}
//定时器
static class MyTask extends TimerTask{

@Override
public void run() {
// TODO Auto-generated method stub
stop=true;
timer.cancel();
}

}

//初试步骤，通过传进来的数组得到路径信息
public void getBasicInformation(String[] g)
{
int layer=0;//表示是第几个空行，同时也可以推知是何种顺序,读出来的结果应该是对的
for(int i=0;i<g.length;i++)
{
if(g[i].equals("") || g[i]==null)//有空行
layer++;
int[] CN=this.changeCharToNum(g[i].toCharArray());//将刚行的文本数据转化为数组数组,CN转化的也是对的
if(layer==0)//第一行信息,第一行的数据是对的
{
this.nodeNum=CN[0];
this.edgNum=CN[1];
this.CondumerNum=CN[2];
this.initNet();//初始化网络
continue;
}
if(layer==1 && !g[i].equals(""))//服务器部署细心
{
this.ServerMoney=CN[0];//System.out.println(this.ServerMoney+"");正确
continue;
}
if(layer==2 && !g[i].equals(""))//出发点 到达点 最大容量 代价,用于构建edges
{
this.addedges(CN[0], CN[1], CN[2], CN[3]);
this.addedges(CN[1], CN[0], CN[2], CN[3]);
this.Adj.get(CN[0]).add(CN[1]);//加入到邻接表,这是因为该算法不考虑空间复杂性所以才那么做的
this.Adj.get(CN[1]).add(CN[0]);//如果算法还考虑空间复杂性，那么可以用NodewithEdges和edge的关系来做
continue;
}
if(layer==3 && !g[i].equals(""))//消费节点编号 消费节点相连节点 需要的最小代价,用于构建超级汇点
{
this.CPosition.add(new int[]{CN[0],CN[1],CN[2]});//这个初始化方法不错
this.CPosi.put(CN[1], CN[0]);
}
}
//一些基于上面的前期准备工作
this.Ss=this.nodeNum;
this.St=this.nodeNum+1;
this.buildSuperT();
}

//第一步选择初试服务器摆放位置,需要路径信息(度和链接信息)
public ArrayList getIntaSeverPosition()
{//先实现简单的，也就是在消费节点相连的节点上放一个
ArrayList<Integer> SP=new ArrayList<Integer>();//用于标示哪些位置用来摆放服务器
for(int i=0;i<this.CondumerNum;i++)
SP.add(this.CPosition.get(i)[1]);
return SP;
}

//第二步开始改进的模拟退火,传如服务器的初试的路径信息
public HashMap dofire(ArrayList SP1)
{
//要用的变量什么的一个声明
Random rand=new Random();//用于生成随机数
int T0=1000,opiter=50000000;//模拟退火的初试温度,模拟退火外循环的迭代次数
//if(this.nodeNum<200)
//opiter=4000;
if(this.nodeNum>200 && this.nodeNum<700)
opiter=1500;
double T;//模拟退火的当前温度
boolean preNeed,nowNeed=true;//记录过去和现在的方案中，所有消费节点的需求是否可以得到满足
int preCost,nowCost=Inf,minCost=Inf;//记录过去和现在方案的花费，最小花费
HashMap Road=new HashMap();//目前记录的是edge的标示
eee=this.deepCloneBaseFor(edge);//因为每次用的都是不同的，这样就不用每次都建了
thead=(int[])head.clone();
//算法正式开始
//针对第一个数据
this.buldSuperS(SP1);//根据传入的服务器位置SP1，构建超级源点
preCost=this.smallCostBigFunction()+SP1.size()*this.ServerMoney;//得到第初试服务器放置的最大流情况下的花费
preNeed=this.checkCNeed();
if(preNeed)//如果能满足条件，则先将路径记录下来
{
minCost=preCost;
Road=this.HashMapdeepclone(this.preRoud);//
//Road=t;//
minSP=(ArrayList)SP1.clone();
}
//针对以后的数据
ArrayList preSP=SP1,nowSP;//原来和现在服务器的摆放位置
//System.out.println("dofire 开始循环");
this.detIter=0;
int[] order=null;
if(this.nodeNum>700)
order=this.calServerGood(SP1.size());
int iter=0;
for(;!stop && iter<opiter;iter++)
{
T=T0/(1+iter);//当前温度

//3中改变策略（增加服务器，减少服务器，改变服务器位置）
nowSP=this.changeServerMethod(preSP,preNeed,iter,order);//因为要知道上一次是谁提供的流量最少，所以把这一条放在了重建网络的前面
//System.out.println("dofire 成功进行了一次 changeServerMethd   "+iter);//也就是问题出现在没有被替换的时候
//错误出现在，如果减少服务器操作没有成功，那么eee也发生了变换，因为我删除的时候已经用到了eee此时，eee肯定不同了，解决方案是在record里面存的不是链路索引，而是要删除的节点号
eee=this.deepCloneBaseFor(edge);//重新恢复到还没有确定服务器的状态
thead=(int[])head.clone();

this.buldSuperS(nowSP);//构建超级汇点
nowCost=this.smallCostBigFunction()+nowSP.size()*this.ServerMoney;
nowNeed=this.checkCNeed();//检查是否满足了所有服务器的要求
if((preNeed&&nowNeed&&preCost>nowCost)||(!preNeed&&nowNeed))//一定发生替换（）
//如果现在的方案满足所有消费节点的需求，且现在方案的nowCost小，则一定替换
{
preCost=nowCost; preSP=nowSP;preNeed=nowNeed;//替换
if(nowCost<minCost)//如果是目前最优的，则记录下来
{
//System.out.println("dofire 替换的路径："+nowSP+"  nowNeed="+nowNeed+"  nowCost="+nowCost);
System.out.println("第"+iter+"次迭代"+"  "+nowCost);
minCost=nowCost;
Road=this.HashMapdeepclone(preRoud);//记录下nowNeed的路径
minSP=(ArrayList)nowSP.clone();
}
if(this.detIter<=4 && this.nodeNum>700)
order=this.calServerGood(nowSP.size());//得到排序后的数组，order里面存储的是边的代号
else
order=null;
continue;
}else{
if(preNeed&&!nowNeed)//一定不发生替换
{
continue;//不替换
}else{
//按照一定的概率进行替换
int erro=nowCost-preCost;
double r=rand.nextDouble();//随机生成一个双精度型
if(r<Math.exp(-(nowCost-preCost)/T))//如果在这一范围内则替换
{
preCost=nowCost; preSP=nowSP;preNeed=nowNeed;//替换
if(this.detIter<=4 && this.nodeNum>700)
order=this.calServerGood(nowSP.size());//得到排序后的数组，order里面存储的是边的代号
else
order=null;
continue;
}else
{
continue;//不替换
}
}
}
}
System.out.println("iter="+iter+"  minCost="+minCost+"  stop="+stop);

return Road;

}

//得到真正的Road，即把负边的给去掉
public HashMap getRealRoud(HashMap old)
{
if(old.isEmpty())
return null;

eee=this.deepCloneBaseFor(edge);//因为每次用的都是不同的，这样就不用每次都建了
this.buldSuperS(minSP);

//System.out.println("getRealRoud  oldRoud:"+old.size());

int len=old.size();
HashMap<Integer,Integer> allE=new HashMap<Integer,Integer>();//用于构建Hash表
HashMap<Integer,ArrayList> realRoud=new HashMap<Integer,ArrayList>();//真正路径
for(int i=0;i<len;i++)//这个循环得到allE，也就是记录每条路径应该走多少流量
{//这个地方不应该是 i<old.size 因为 old有remove操作，会导致它的长度越来越小，导致循环过早结束
ArrayList<Integer> sub=(ArrayList<Integer>)old.get(i);//得到第i条路径
for(int j=0;j<sub.size()-1;j++)//将所有的边放在Hash表中，计算每条边实际走了多少流量，也就是去除负边的情况下一共有多少流量
{//注意，sub的最后一位是目前该条线路的流量,除最后一位的前几位，应该是节点的索引
//本来这个地方错了，在allE中，应该是不存储负边的
int idex=sub.get(j);
if(idex%2!=0)
idex=idex^1;
if(allE.get(idex)==null)//如果目前还没有存入,则初始化为0
allE.put(idex, 0);
int flow=allE.get(idex);
if((int)sub.get(j)%2==0)//(不是我们构建Ss或St加的边 && 边的标示是偶数)
flow=flow+(int)sub.get(sub.size()-1);
else//如果是负边
flow=flow-(int)sub.get(sub.size()-1);
allE.remove(idex);//将allE中的flow更新成最新的
allE.put(idex, flow);
}
}
//从allE的数据中得到路径-->构建HashMap-->根据HashMap找路径
//构建HashMap
HashMap<Integer,LinkedList> find=new HashMap<Integer,LinkedList>();
Set s=allE.keySet();
Iterator it=s.iterator();
for(;it.hasNext();)
{
int edex=(int)it.next();
int u=this.eee.get(edex).u;//头结点
int v=this.eee.get(edex).v;//尾节点
if(find.get(u)==null)//如果暂时无此头结点,则让它有孩子
{
LinkedList<int[]> son=new LinkedList<int[]>();
find.put(u, son);
}
LinkedList<int[]> temp=find.get(u);//找到头结点u对应的尾节点表
if(allE.get(edex)!=0)//因为有个118到70的路径不知道是什么鬼
temp.add(new int[]{u,v,allE.get(edex)});//在尾节点里分别存入{头结点，尾节点，allFlow}
else//因为出现有 118 但是 size=0 这就说明118加了个空的，那么应该就是这里删去，这是因为走正走负，导致有些边其实没有走
{//一直认为是后面错了，想不到。。。。
if(find.get(u).isEmpty())
find.remove(u);
}
}
//根据HashMap找路径
int reallen=0;//做realRoud的key
while(!find.isEmpty())//当find表不为空时
{
ArrayList<Integer> path=new ArrayList<Integer>();
int hh=Ss;
int min=Inf;
int[] shiyan=new int[3];
while(hh!=St)//当不是超级汇点的时候
{
int mq=((LinkedList<int[]>)find.get(hh)).getFirst()[2];
if(min>mq)
min=mq;
shiyan=((LinkedList<int[]>)find.get(hh)).getFirst();
hh=shiyan[1];
path.add(hh);
}
path.remove(path.size()-1);//将超级汇点去掉
hh=Ss;//head我已经定义为全局变量了
while(hh!=St)//根据minflow，更改路径上的allFlow，如果allFlow为0则删除，如果被删除的头结点也为空了，则也删除对应find上的一行
{
((LinkedList<int[]>)find.get(hh)).getFirst()[2]-=min;
int next=((LinkedList<int[]>)find.get(hh)).getFirst()[1];
if(((LinkedList<int[]>)find.get(hh)).getFirst()[2]==0)
{
((LinkedList<int[]>)find.get(hh)).removeFirst();//如果等于0，则删除
if(((LinkedList<int[]>)find.get(hh)).isEmpty())
find.remove(hh);//如果没有了尾节点，则删除该HashMap的head边
}
hh=next;
}
path.add(this.CPosi.get(path.get(path.size()-1)));//加入消费者的编号
path.add(min);//在path中增加minflow
realRoud.put(reallen++, path);//在realRoud中增加path
}

System.out.println("-----------测试整体供给和整体需求--------------");
int sum1=0,sum2=0;
for(int i=0;i<realRoud.size();i++)
{
ArrayList<Integer> pa=realRoud.get(i);
sum1+=pa.get(pa.size()-1);
}
for(int i=0;i<this.CondumerNum;i++)
sum2+=this.CPosition.get(i)[2];
System.out.println(" path sum--->"+sum1);
System.out.println(" real sum--->"+sum2);
System.out.println("----------------------------------------");

return realRoud;
}

//模拟退火需要的cost function最小花费最大流
public int smallCostBigFunction()
{
//前面先进行一些数据的预处理工作
//正式开始执行算法
this.preRoud.clear();//清除上一次得到的路径
//this.smallCost=0;
int minflow,minCost=0,len=0;
while(spfa(this.nodeNum+2))//这个n还需不要要加2
{
ArrayList<Integer> subpath=new ArrayList<Integer>();
minflow=Inf+1;
//求线路允许通过的最大流量，也就是这条线路中包含路径的最小cap
for(int i=subPath[St];i!=-1;i=subPath[eee.get(i).u])
{
subpath.add(i);//包含超级源点路径，也包含超级汇点路径,但是是逆序的
if(eee.get(i).cap<minflow)
minflow=eee.get(i).cap;
}
subpath.add(minflow);//将线路此时的流量信息放到最后一位
preRoud.put(len++, subpath);//记录路径,这时候记录的是  subpath里的所有信息  和 该线路上的流量
for(int i=subPath[St];i!=-1;i=subPath[eee.get(i).u])
{
eee.get(i).cap-=minflow;
eee.get(i^1).cap+=minflow;//异或操作，对应了改经过边的所对应的反边
}
minCost+=Dis[St]*minflow;//Dis中已将包含了Cost的信息，所以不用重新再考虑

}
return minCost;
}

//最小花费最大流需要的spfa算法,传入的量是超级源点的标号，超级汇点的编号，和所有的节点数目
public boolean spfa(int allNode)
{
Queue<Integer> qu=new LinkedList<Integer>();
boolean[] vis=new boolean[this.nodeNum+2];
for(int i=0;i<subPath.length;i++)
{
subPath[i]=-1;
Dis[i]=Inf;
vis[i]=false;//没有在队列里
}
Dis[Ss]=0;
qu.add(Ss);
vis[Ss]=true;
while(!qu.isEmpty())
{
int hnode=qu.remove();
vis[hnode]=false;
for(int i=this.thead[hnode];i!=-1;i=eee.get(i).next)//找到所有以hnode为头结点的边
{
int tnode=eee.get(i).v;//找到以hnode为头的弧的尾节点
//如果可以这个链路可以过，且代价小
if(eee.get(i).cap>0 && Dis[tnode]>Dis[hnode]+eee.get(i).cost)
{
Dis[tnode]=Dis[hnode]+eee.get(i).cost;
subPath[tnode]=i;//记录路径
if(vis[tnode]==false)//如果尾节点不再队列里面
{
qu.add(tnode);
vis[tnode]=true;
}
}
}
}
if(Dis[St]>=Inf)
return false;
return true;
}

//最后一步，将得到的结果转化为符合条件的字符串数组
public String[] changeForm(HashMap Roud)
{
if(Roud==null)//如果没有找到路径，则返回一个空指针
return null;
//如果找到了路径
//System.out.println("changeForm中最终找到的路径数目是："+Roud.size());
String[] contents=new String[Roud.size()+2];//
contents[0]=Roud.size()+"";//第一行，路径数
int i=1;
for(;i<Roud.size()+2;i++)
contents[i]="";
i=2;
Set s=Roud.keySet();
Iterator it=s.iterator();
for(;it.hasNext();)
{
int k=(int)it.next();
ArrayList<Integer> everyRoud=(ArrayList<Integer>)Roud.get(k);
for(int j=0;j<everyRoud.size();j++)
{
if(j!=everyRoud.size()-1)
contents[i]+=everyRoud.get(j)+" ";
else
contents[i++]+=everyRoud.get(j)+"";//最后一个是容量，后面应该没有空格
}
}

return contents;

}

//改变服务器放置的三种策略
public ArrayList changeServerMethod(ArrayList SP1,boolean need,int iter,int[] order)
{
ArrayList SP=(ArrayList)SP1.clone();
Random rr=new Random();//生成随机量
double meths=rr.nextDouble();//确定以下三种方法的随机量
double addS,detS;
if(this.nodeNum<800)//如果不是高级样例
{
if(this.nodeNum<300)
{
addS=0.18;
detS=0.5;
}else
{
addS=0.1;//增加服务器的概率
detS=0.5;
if(iter<=300)
detS=0.72;
}
}else
{
addS=0.1;//增加服务器的概率
detS=0.8;
if(iter>200)
detS=0.7;
}
//methed 1:增加服务器数量
if(SP1.size()<this.CondumerNum && (need==false || meths<addS))
{
System.out.println("增加服务器操作");
while(true)//当没有加入成功
{
int add=rr.nextInt(this.nodeNum);//在除超级源点和超级汇点的网络节点里随机选择一个加入
if(SP.indexOf(add)==-1)//说明没有在原来的服务器中
{
SP.add(add);
break;
}
}
return SP;
}
//method 2:减少服务器器数量
if(SP.size()>1 && meths>=addS && meths<detS)
{
System.out.println("减少服务器操作");
if(this.nodeNum<700 || this.detIter>4)
{
int min=Inf;
int minN=0;
for(int i=Sb+1;i<=Se;i=i+2)
{
//System.out.print(eee.get(i).u+"("+eee.get(i).cap+")   ");
if(eee.get(i).cap<min)
{
min=eee.get(i).cap;
minN=eee.get(i).u;//真实的源点应该是超级节点的尾节点,但是因为这是负边，所以真实的是源点就是边的头结点
}
}
int del;
if(minN==minNode)//说明现在出现了删除该最小的就满足不了消费节点的需求的情况
del=rr.nextInt(SP.size());
else
{
this.minNode=minN;
del=SP.indexOf(this.minNode);
if(del==-1)//当前一步没替换换时，会出现这样的情况
del=rr.nextInt(SP.size());
}
SP.remove(del);

if(this.nodeNum>700 && iter<25)
{
int del2=rr.nextInt(SP.size());
SP.remove(del2);
}
}else
{//针对高级用例的前几次，大幅度减少节点的数量

int detNum=0;
switch(this.detIter)
{
case 0://删除50个
detNum=50;
break;
case 1://删除30个
detNum=30;
break;
case 2://删除20个
detNum=20;
break;
case 3://删除10个
detNum=10;
break;
default://删除5个
detNum=5;
break;

}
for(int gaod=0;gaod<detNum;gaod++)
{
//int dell=eee.get(order[gaod]).u;
int del2=SP.indexOf(order[gaod]);
if(del2==-1)
del2=rr.nextInt(SP.size());
SP.remove(del2);
}

this.detIter++;
}

return SP;
}
//method 3:改变服务器位置
if(meths>=detS)
{
System.out.println("改变服务器位置");
while(true)//当没有加入成功
{
int add=rr.nextInt(this.nodeNum);//在除超级源点和超级汇点的网络节点里随机选择一个加入
if(SP.indexOf(add)==-1)//说明没有在原来的服务器中
{
SP.add(add);
break;
}
}
//删除一台服务器
int min=Inf;
int minN=0;
for(int i=Sb+1;i<=Se;i=i+2)
{
//System.out.print(eee.get(i).u+"("+eee.get(i).cap+")   ");
if(eee.get(i).cap<min)
{
min=eee.get(i).cap;
minN=eee.get(i).u;//真实的源点应该是超级节点的尾节点,但是因为这是负边，所以真实的是源点就是边的头结点
}
}
int del=SP.indexOf(minN);
if(del==-1)//当前一步没替换换时，会出现这样的情况
del=rr.nextInt(SP.size());
SP.remove(del);
}
return SP;
}
////////////////////////上面主要函数所要调用的一些小函数////////////\
//将带空格，且最大是千位的书转型
public int[] changeCharToNum(char[] cc)
{
int cishu=0,len,zi=0;
int[] Num=new int[4];
for(;zi<cc.length;zi++)
{
len=0;
for(;zi<cc.length && cc[zi]!=' ';zi++)//看看这个数字有多少位
len++;
//根据len得到数字，并将该数字存入数组
int sum=0;
for(int i=0;i<len;i++)//将每个char转化为数字，并qui和
sum+=((int)(cc[zi-i-1]-48))*((int)Math.pow(10, i));
Num[cishu]=sum;
cishu++;
}
return Num;
}
//构建网络时的加边操作
public void addedges(int u,int v,int cap,int cost)
{
Edge e=new Edge(u,v,cap,cost,head[u]);//正向边
this.edge.add(e);
head[u]=(edge.size()-1);//以u为头结点的弧所在的边的位置
Edge ee=new Edge(v,u,0,-cost,head[v]);//反向边
this.edge.add(ee);
head[v]=(edge.size()-1);//以v为头结点的弧所在的边的位置
}
//构建网络时的加边操作
public void addedgesthead(int u,int v,int cap,int cost)
{
Edge e=new Edge(u,v,cap,cost,thead[u]);//正向边
this.eee.add(e);
thead[u]=(eee.size()-1);//以u为头结点的弧所在的边的位置
Edge ee=new Edge(v,u,0,-cost,thead[v]);//反向边
this.eee.add(ee);
thead[v]=(eee.size()-1);//以v为头结点的弧所在的边的位置
}
//构建网络的初始化网络操作
public void initNet()
{
this.head=new int[this.nodeNum+2];//因为肯定会有一个超级源点，一个超级汇点
this.subPath=new int[this.nodeNum+2];
this.Dis=new int[this.nodeNum+2];
for(int i=0;i<head.length;i++)
{
head[i]=-1;
subPath[i]=-1;
}
for(int j=0;j<this.nodeNum;j++)
{
ArrayList<Integer> aa=new ArrayList<Integer>();
this.Adj.put(j, aa);
}
}
//构建超级汇点
public void buildSuperT()
{
Tb=edge.size();
for(int i=0;i<this.CondumerNum;i++)
{
int c=this.CPosition.get(i)[1];
this.addedges(c, this.St, CPosition.get(i)[2], 0);
}
Ts=edge.size()-1;
this.minNode=Inf;
this.minNode2=Inf;
}
//构建超级源点
public void buldSuperS(ArrayList SP)
{
this.Sb=eee.size();
for(int i=0;i<SP.size();i++)
{
int node=(int)SP.get(i);
this.addedgesthead(Ss, node, Inf, 0);
}
this.Se=eee.size()-1;
//this.detIter=0;
}
//判断是否所有消费节点的需求都得到了满足
public boolean checkCNeed()
{
for(int i=Tb;i<=Ts;i=i+2)//因为加1之后是反边
{
if(eee.get(i).cap>0)
return false;
}
return true;
}
//HashMap的克隆方法
public HashMap<Integer,ArrayList> HashMapdeepclone(HashMap<Integer,ArrayList> Old)
{
HashMap<Integer,ArrayList> New=new HashMap<Integer,ArrayList>();
for(int i=0;i<Old.size();i++)
{
ArrayList<Integer> aa=new ArrayList<Integer>();
ArrayList<Integer> ao=(ArrayList)Old.get(i);
aa=(ArrayList)ao.clone();//不能成功拷贝的程序
New.put(i, aa);
}
return New;
}

//测试用clone方法1：重写clone方法，将ArrayList遍历，clone到底
public ArrayList deepCloneBaseFor(ArrayList n)
{
ArrayList<Edge> r=new ArrayList<Edge>();
for(int i=0;i<n.size();i++)
{
Edge e=(Edge)((Edge)n.get(i)).clone();
r.add(e);
}
return r;
}

//按服务器节点所供给的容量，对服务器节点进行排序，返回一个数组，数组里面存储的是边的代号
//采用归并排序
public int[] calServerGood(int len)
{
//System.out.println("SP.size()="+len+"   Sb="+Sb+"  Se="+Se);
int[][] record=new int[2][len];
int jt=0;
for(int i=Sb+1;i<=Se;i=i+2)
{
record[0][jt]=eee.get(i).u;//链路的索引
record[1][jt++]=eee.get(i).cap;//要排的数数据
}
int[][] temp=new int[2][len];
this.mergeSort(record, 0, len-1, temp);
int[] result=new int[len];
for(int i=0;i<len;i++)
result[i]=record[0][i];
return result;
}

public void mergeSort(int[][] a,int f,int l,int temp[][])//排序的主算法
{
if(f<l)
{
int mid=(f+l)/2;
mergeSort(a,f,mid,temp);//左边有序
mergeSort(a,mid+1,l,temp);//右边有序
this.addMerge(a,f,mid,l,temp);//合并有序数组a[f..mid]和a[mid+1...l]到temp
}
}

public void addMerge(int[][] a,int f,int mid,int l,int[][] temp)//排序用的合并算法
{
int i=f,j=mid+1,m=mid,n=l,k=0;
while(i<=m && j<=n)
{
if(a[1][i]<=a[1][j])
{
temp[0][k]=a[0][i];
temp[1][k++]=a[1][i++];
}
else
{
temp[0][k]=a[0][j];
temp[1][k++]=a[1][j++];
}
}
while(i<=m)//当前半部分多
{
temp[0][k]=a[0][i];
temp[1][k++]=a[1][i++];
}
while(j<=n)//当后半部分多
{
temp[0][k]=a[0][j];
temp[1][k++]=a[1][j++];
}
for(i=0;i<k;i++)//会写到a中，可以进行不写回的优化
{
a[0][f+i]=temp[0][i];
a[1][f+i]=temp[1][i];
}
}
}