第一届全国高校软件定义网络（SDN）应用创新开发大赛题目 ·
-----by 温州大学 蒋暕青
本次大赛以提交报告书的形式进行初赛，参赛队伍须根据题目要求写出报告书文档，在初赛截止日期之前在线提交。
初赛基本要求：初赛共三大题，满分100分。必答题的总得分在60%（即18分）或以上的，方可获得参赛证明，并获得算法题和设计题的评分资格。以三大题的总分计算，排出入围决赛的名单。
参赛队伍在线提交时，要提供一个list.txt文件，内容是所提交的文件名列表，每个文件名对应一句话的简要说明。同一参赛队伍可以多次提交，以最后一次提交的文件为准。
第一题：必答题（搭建SDN网络环境）——30分
必答题一共三小题，根据每小题的完成程度和报告质量来评分，主要考察以下三个方面：
1.能否成功搭建SDN网络环境（基于物理设备或者虚拟化技术都是允许的）；
2.能否通过集中式的控制来控制整个网络（主要通过能否集中式的控制流表或者路由信息来评判）；
3.能否给出详细的实验报告（包括方案描述、操作步骤以及实验结果，每小题一份报告）。
第1小题：简单网络（5分）
说明：由于对于SDN架构的理解在学界和业界并没有统一，为了方便参赛队员选择，对于初学者，大赛推荐OpenFlow作为南向接口来实现SDN环境，以下给出分别针对采用OpenFlow和采用其他接口的具体要求（分A、B两种情况）。
A. 针对采用OpenFlow作为南向接口的参赛队伍的要求：
参赛队伍首先需要搭建一个SDN架构的网络环境，初学者可以参照图1所示的一个最简单的拓扑结构，熟练的参赛队员可以自定义复杂一点的拓扑结构，两者并不影响评委评分。
B. 针对不是采用OpenFlow作为南向接口的参赛队伍的要求：
拓扑结构自定，所用设备、软件等自选，只要能够实现SDN架构的网络环境即可。
图1：简单的示例拓扑
1.搭建环境要求：图1中控制器可以自主选择，既可选择各种开源的控制器（例如：Floodlight、Ryu、Nox、Beacon、Trema、OpenDaylight等），也可选择由本次大赛设备提供商所提供的闭源控制器。拓扑中各网络部件既可以是仿真环境实现（例如mininet， OpenvSwtich），有条件的队伍也可以通过物理设备实现，两种方案不影响必答题的评分。
2.操作要求：对流表进行操作使得Host1和Host2能够互相ping通，然后再修改流表使得它们不能ping通。
3.报告书要求：报告书的主要内容需要包含以下几点：
(1)详细描述实验网络环境的搭建思路，给出搭建出来的结构拓扑图，列举选择的具体设备或者仿真软件、工具软件，并说明其在实验中的作用。
(2)给出实现2中操作要求的具体操作步骤，以截图或者文本方式展示，要求给出初始以及前后两次对流表操作后流表内容的截图。
(3)给出实验数据（界面截图、表格等都可）来说明实现了(2)中的要求。
说明：以上列举的为硬性要求，在报告书中必须给出。但报告书内容的组织可以灵活处理，自由发挥，不限于上述要求的内容。
第一小题：
建立拓扑：
sudo mn –topo single,3 –mac –switch ovsk –controller=remote,ip=192.168.43.128,port=6633
Pingall都能ping通
控制器web界面显示
现在修改流表让主机相互ping 不通
查看端口：ovs-vsctl show
先pingall
通了
来改流表：ovs-ofctl add-flow s1 priority=1,in_port=2,actions=drop
到port 2的流量全部drop
H1的端口port2 不能ping通H2 H3主机
成功！
第2小题：逻辑隔离（10分）
1. 背景：云平台服务器上的不同虚拟服务器，分属于不同的用户。用户远程登录自己的虚拟服务器之后，安全上不允许直接访问同一局域网的其他虚拟服务器。
2. 场景：设有一台PC机，两台服务器A、B与同一交换机直连，服务器A和B都提供远程桌面登录服务。（这里的PC机、服务器、交换机可以选择物理设备或者虚拟机实现）。
3. 目的：通过控制层对网络的控制，实现PC机可以分别登录服务器A和B，但是A和B之间相互访问不了（无论是在实际环境还是在仿真环境实现目的均可，不影响评分）。
4. 针对采用OpenFlow的参考示例：（具体方案可自由发挥）参考的网络拓扑如图2所示，通过对流表的修改与编辑，使得访问A、B的流能够被区分出来，如果是A访问B或者B访问A的流则自动丢弃，否则正常处理。
5. 报告书要求：
(1) 简要描述网络拓扑，给出拓扑图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。
(2) 给出操作步骤。
(3) 给出实验数据（界面截图、表格等都可），证明目的已经实现。
图2：参考示例网络拓扑
Mininet上搭建拓扑
如第一小题做A到B的drop
B到A的drop
第3小题：岗位轮换（15分）
1. 背景：虚拟服务器防入侵、防篡改攻击，让虚拟服务器轮流承担同一岗位的任务，轮换下去的虚拟机做快速系统还原。
2. 设有一台PC机，两台Web服务器A和B提供简单的静态网页访问服务，服务器A和B直连在同一交换机上。两台服务器所显示的网页有显著差别，可以是不同的网页内容或者不同颜色，能够区分彼此即可。（这里的PC机、Web服务器、交换机可以选择物理设备或者虚拟机实现）
3. 目的：当PC机不停的发出访问请求时，控制层能够控制网络自动交替轮流将访问请求转发到两个服务器上。
4. 报告书要求：
(1) 简要描述网络拓扑，给出拓扑图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。
(2) 给出操作步骤。
(3) 给出实验数据，证明目的已经实现。
用mininet的Python接口创建自定义拓扑
mn –custom /home/ubuntu/mininet/custom/topo-2sw-2host.py –topo mytopo –switch ovsk –controller=remote,ip=192.168.43.128,port=6633
H3 和H4都开httpserver
H1和H2去wget H3和H4的服务都成功了
轮转ping一个共有的10.0.0.100IP成功，其中10.0.0.3,10.0.0.4轮转响应
WWW服务轮转成功
第二题：算法题（SDN算法设计）——20分（）
要求：写出如下路由算法程序，并且进一步将算法做成SDN控制器中的一个APP路由功能。给出程序代码以及加入SDN控制器中的具体步骤，并给出实验数据，证明目的已实现。
第1步：路由算法编程（8分）
下面为示例拓扑图，我们要用算法计算出id为1设备到id为7的设备和设备id为2到id为8设备的最优路线。
图3：组网拓扑
说明：此处拓扑图仅作为一个举例，路由算法程序应该能够处理各种拓扑情况，只要输入数据符合格式要求。程序应能够处理不同的Input.txt数据，并且可以处理带宽资源约束（input第一段最后属性）和路径需求（input第二段最后属性）。
- 输入：
图3拓扑的输入文件为input.txt，本算法为双向线，来回只需输入一个即可
Input.txt：
leftnodeID,rightnodeID,bandwidth
1,3,100
1,4,100
2,3,100
2,4,100
3,4,100
3,5,100
3,6,100
4,5,100
4,6,100
5,6,100
5,7,100
5,8,100
6,7,100
6,8,100
;
srcNodeID,dstNodeID,bandwidth
1,7,90
1,8,90
其中leftnodeID为左节点（字段名固定），rightnodeID右节点（字段名固定），bandwidth带宽，srcNodeID源节点（字段名固定）,dstNodeID目的节点（字段名固定），根据算法不同，字段名可以按需增加。
- 运算：
C:\Users\xwx202247>算法.exe input.txt output.txt - 输出：
经算法计算后的计算结果输出文件output.txt
Output.txt:
1,3,6,7
2,4,5,8
代码如下：
<code class="hljs cs has-numbering">import java.io.*;
import java.util.*;
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> RouteDesign {
final <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> maxnum = <span class="hljs-number">100</span>;
final <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> minint = <span class="hljs-number">0</span>;
final <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> maxint = <span class="hljs-number">999999</span>;
<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> dist [] = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span> [maxnum]; <span class="hljs-comment">//当前路径中的最小带宽</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> mprev[] = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span> [maxnum]; <span class="hljs-comment">//当前节点的前一跳节点</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> c[][] = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span> [maxnum][maxnum]; <span class="hljs-comment">// 两个节点之间的带宽</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> hop[] = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span> [maxnum]; <span class="hljs-comment">//当前节点到源节点的跳数</span>
<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Dijkstra</span>(<span class="hljs-keyword">int</span> n,<span class="hljs-keyword">int</span> v,<span class="hljs-keyword">int</span> b,<span class="hljs-keyword">int</span> dist[],<span class="hljs-keyword">int</span> mprev[],<span class="hljs-keyword">int</span> c[][]){
boolean s[] = <span class="hljs-keyword">new</span> boolean[maxnum];
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">1</span>;i<=n;i++){
dist[i] = c[v][i]; <span class="hljs-comment">//这个循环用来说明当前链路到源节点的带宽，寻找源节点可以到达的所有节点</span>
s[i]=<span class="hljs-keyword">false</span>;
<span class="hljs-keyword">if</span>(dist[i]==minint)
mprev[i] = <span class="hljs-number">0</span>; <span class="hljs-comment">//当前节点的前一跳节点为0</span>
<span class="hljs-keyword">else</span>{
mprev[i] = v; <span class="hljs-comment">//否则前一跳为源节点 </span>
hop[i]=<span class="hljs-number">1</span>; <span class="hljs-comment">//重置跳数</span>
}
}
dist[v] = maxint;
s[v] = <span class="hljs-keyword">true</span>; <span class="hljs-comment">//源节点s[v]为true</span>
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">2</span>;i<=n;i++){
<span class="hljs-keyword">int</span> tmp = b; <span class="hljs-comment">//tmp为所要求的带宽</span>
<span class="hljs-keyword">int</span> u = v; <span class="hljs-comment">//u为源节点</span>
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> j=<span class="hljs-number">1</span>;j<=n;j++){
<span class="hljs-keyword">if</span>(!s[j]&&dist[j]>=tmp){ <span class="hljs-comment">//s[j]为0并且当前带宽大于要求带宽 </span>
u=j; <span class="hljs-comment">//源节点等于当前节点</span>
tmp=dist[j]; <span class="hljs-comment">//保证带宽不会减小</span>
}
}
s[u]=<span class="hljs-keyword">true</span>;
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> j=<span class="hljs-number">1</span>;j<=n;j++){
<span class="hljs-keyword">int</span> least = dist[u]; <span class="hljs-comment">//least为u的带宽 </span>
<span class="hljs-keyword">if</span>(c[u][j]<dist[u])
least=c[u][j]; <span class="hljs-comment">//最得u到其他节点最小带宽值</span>
<span class="hljs-keyword">if</span>((!s[j])&&(least>dist[j])){ <span class="hljs-comment">//如果当前节点到源点的路径中的带宽过小，更新当前节点最小带宽及路径</span>
hop[j]=hop[u]+<span class="hljs-number">1</span>;
mprev[j]=u;
dist[j]=least;
}
<span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span>(!s[j]&&(least == dist[j])){ <span class="hljs-comment">//如果相等则比较跳数，跳数小者成为当前节点的路径</span>
<span class="hljs-keyword">if</span>(hop[j]>hop[u]+<span class="hljs-number">1</span>){
hop[j]=hop[u]+<span class="hljs-number">1</span>;
mprev[j]= u;
dist[j]=least;
}
}
}
}
}
<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">searchPath</span>(<span class="hljs-keyword">int</span> mprev[],<span class="hljs-keyword">int</span> v,<span class="hljs-keyword">int</span> u,String output) throws FileNotFoundException{
OutputStream <span class="hljs-keyword">out</span> = <span class="hljs-keyword">new</span> FileOutputStream(output,<span class="hljs-keyword">true</span>);
<span class="hljs-keyword">int</span> que[] = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span>[maxnum];
<span class="hljs-keyword">int</span> tot=<span class="hljs-number">1</span>;
que[tot]=u;
tot++;
<span class="hljs-keyword">int</span> tmp = mprev[u]; <span class="hljs-comment">//tmp为目的节点之前的节点</span>
<span class="hljs-keyword">while</span>(tmp!=v){ <span class="hljs-comment">//目的节点与源节点v不相等</span>
que[tot] =tmp;
tot++;
tmp=mprev[tmp]; <span class="hljs-comment">//从目的节点回溯 </span>
}
que[tot]=v; <span class="hljs-comment">//tot的值为回溯的次数 </span>
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i = tot;i>=i;i--){
<span class="hljs-keyword">if</span>(i!=<span class="hljs-number">1</span>){
<span class="hljs-keyword">int</span> num=que[i];
<span class="hljs-keyword">try</span>{
<span class="hljs-keyword">out</span>.write(String.valueOf(num).getBytes()); <span class="hljs-comment">//一个字符串转化为一个字节数组</span>
<span class="hljs-keyword">out</span>.write(<span class="hljs-string">","</span>.getBytes());
}<span class="hljs-keyword">catch</span> (IOException e){
e.printStackTrace(); <span class="hljs-comment">//打印堆栈内容</span>
}
}
<span class="hljs-keyword">else</span>{
<span class="hljs-keyword">try</span>{
<span class="hljs-keyword">out</span>.write(String.valueOf(que[i]).getBytes());
<span class="hljs-keyword">out</span>.write(<span class="hljs-string">"\r\n"</span>.getBytes());
}<span class="hljs-keyword">catch</span>(IOException e){
e.printStackTrace();
}
}
}
<span class="hljs-keyword">try</span>{
<span class="hljs-keyword">out</span>.close();
}<span class="hljs-keyword">catch</span>(IOException e){
e.printStackTrace();
}
}
<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span>(String[] args) throws IOException {
<span class="hljs-comment">// TODO Auto-generated method stub</span>
String input = args[<span class="hljs-number">0</span>]; <span class="hljs-comment">//而这个main方法有所不同的是：它是所有方法中最先运行的一个，所以没有其他方法给它传递参数，所以需要靠运行时命令行输入参数，所以String args,接收的是命令行的输入</span>
String output = args[<span class="hljs-number">1</span>];
BufferedReader <span class="hljs-keyword">in</span> = <span class="hljs-keyword">new</span> BufferedReader(<span class="hljs-keyword">new</span> InputStreamReader(<span class="hljs-keyword">new</span> FileInputStream(<span class="hljs-keyword">new</span> File(input))) );
String str = <span class="hljs-keyword">new</span> String ();
<span class="hljs-keyword">int</span> NodeNum=<span class="hljs-number">0</span>;
<span class="hljs-keyword">int</span> LineNum=<span class="hljs-number">0</span>;
Vector<String>vstr = <span class="hljs-keyword">new</span> Vector<String>();
Vector<String>dstr = <span class="hljs-keyword">new</span> Vector<String>(); <span class="hljs-comment">// java 中可以实现自动增长的对象数组</span>
str = <span class="hljs-keyword">in</span>.readLine(); <span class="hljs-comment">//读取一个文本行 </span>
<span class="hljs-keyword">while</span>(<span class="hljs-keyword">true</span>){
str=<span class="hljs-keyword">in</span>.readLine();
<span class="hljs-keyword">if</span>(str.isEmpty()){
<span class="hljs-keyword">break</span>;
}
vstr.add(str); <span class="hljs-comment">// 把读入的对象加在vstr中</span>
LineNum++;
}
<span class="hljs-keyword">in</span>.readLine();
<span class="hljs-keyword">in</span>.readLine();
<span class="hljs-keyword">while</span>(<span class="hljs-keyword">true</span>){
str=<span class="hljs-keyword">in</span>.readLine();
<span class="hljs-keyword">if</span>(str==<span class="hljs-keyword">null</span>)
<span class="hljs-keyword">break</span>;
<span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span>(str.isEmpty())
<span class="hljs-keyword">break</span>;
dstr.add(str); <span class="hljs-comment">// 把目的读入的对象加在dstr中</span>
}
String LastLine = (String)vstr.lastElement();
String[] strdata = LastLine.split(<span class="hljs-string">"\\,"</span>);
<span class="hljs-keyword">int</span> firststr = Integer.parseInt(strdata[<span class="hljs-number">0</span>]);
<span class="hljs-keyword">int</span> secondstr = Integer.parseInt(strdata[<span class="hljs-number">1</span>]); <span class="hljs-comment">//根据，分割录入信息</span>
<span class="hljs-keyword">if</span>(firststr<secondstr)
NodeNum = secondstr;
<span class="hljs-keyword">else</span>
NodeNum = firststr;
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">1</span>;i<NodeNum;i++){
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> j=<span class="hljs-number">1</span>;j<NodeNum;j++){
c[i][j]=minint; <span class="hljs-comment">//建立整个拓扑</span>
}
}
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">1</span>;i<=LineNum;i++){
String Readvstr = (String)vstr.<span class="hljs-keyword">get</span>(i-<span class="hljs-number">1</span>); <span class="hljs-comment">//get一个数字</span>
String [] vstrdata = Readvstr.split(<span class="hljs-string">"\\,"</span>);
<span class="hljs-keyword">int</span> firstvstr = Integer.parseInt(vstrdata[<span class="hljs-number">0</span>]);
<span class="hljs-keyword">int</span> secondvstr = Integer.parseInt(vstrdata[<span class="hljs-number">1</span>]);
<span class="hljs-keyword">int</span> thirdvstr = Integer.parseInt(vstrdata[<span class="hljs-number">2</span>]);
<span class="hljs-keyword">if</span>(thirdvstr>c[firstvstr][secondvstr]){
c[firstvstr][secondvstr]=thirdvstr; <span class="hljs-comment">//取最小带宽 </span>
c[secondvstr][firstvstr]=thirdvstr;
}
}
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">1</span>;i<NodeNum;i++){
dist[i]=minint;
hop[i]=minint;
}
<span class="hljs-keyword">int</span> src,dst,bdw;
OutputStream <span class="hljs-keyword">out</span> = <span class="hljs-keyword">new</span> FileOutputStream(output,<span class="hljs-keyword">false</span>);
<span class="hljs-keyword">out</span>.write(<span class="hljs-string">""</span>.getBytes());
<span class="hljs-keyword">out</span>.close();
<span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i=<span class="hljs-number">1</span>;i<=dstr.size();i++){
String Readvstr = (String)dstr.<span class="hljs-keyword">get</span>(i-<span class="hljs-number">1</span>);
String sdstr[] =Readvstr.split(<span class="hljs-string">","</span>);
src = Integer.parseInt(sdstr[<span class="hljs-number">0</span>]);
dst = Integer.parseInt(sdstr[<span class="hljs-number">1</span>]);
bdw = Integer.parseInt(sdstr[<span class="hljs-number">2</span>]);
Dijkstra(NodeNum,src,bdw,dist,mprev,c);
searchPath(mprev,src,dst,output);
}
}
}</code>
第2步：控制器路由功能（12分）
把路由算法作为APP加入到控制器中，使SDN网络实现根据拓扑情况自动选择路由的功能。
报告书要求：
(1) 简要描述实现思路，给出系统设计图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。
(2) 给出操作步骤。
(3) 给出实验数据，证明目的已经实现。
由于floodlight控制器本身的路由策略就是基于迪杰斯特拉算法的，因此就不加入此算法了。
详情见fl的topology模块的topologyinstanc.java
<code class="hljs cs has-numbering"><span class="hljs-keyword">protected</span> BroadcastTree <span class="hljs-title">dijkstra</span>(Cluster c, Long root,
Map<Link, Integer> linkCost,
boolean isDstRooted) {
HashMap<Long, Link> nexthoplinks = <span class="hljs-keyword">new</span> HashMap<Long, Link>();
<span class="hljs-comment">//HashMap<Long, Long> nexthopnodes = new HashMap<Long, Long>();</span>
HashMap<Long, Integer> cost = <span class="hljs-keyword">new</span> HashMap<Long, Integer>();
<span class="hljs-keyword">int</span> w;
<span class="hljs-keyword">for</span> (Long node: c.links.keySet()) {
nexthoplinks.put(node, <span class="hljs-keyword">null</span>);
<span class="hljs-comment">//nexthopnodes.put(node, null);</span>
cost.put(node, MAX_PATH_WEIGHT);
}
HashMap<Long, Boolean> seen = <span class="hljs-keyword">new</span> HashMap<Long, Boolean>();
PriorityQueue<NodeDist> nodeq = <span class="hljs-keyword">new</span> PriorityQueue<NodeDist>();
nodeq.add(<span class="hljs-keyword">new</span> NodeDist(root, <span class="hljs-number">0</span>));
cost.put(root, <span class="hljs-number">0</span>);
<span class="hljs-keyword">while</span> (nodeq.peek() != <span class="hljs-keyword">null</span>) {
NodeDist n = nodeq.poll();
Long cnode = n.getNode();
<span class="hljs-keyword">int</span> cdist = n.getDist();
<span class="hljs-keyword">if</span> (cdist >= MAX_PATH_WEIGHT) <span class="hljs-keyword">break</span>;
<span class="hljs-keyword">if</span> (seen.containsKey(cnode)) <span class="hljs-keyword">continue</span>;
seen.put(cnode, <span class="hljs-keyword">true</span>);
<span class="hljs-keyword">for</span> (Link link: c.links.<span class="hljs-keyword">get</span>(cnode)) {
Long neighbor;
<span class="hljs-keyword">if</span> (isDstRooted == <span class="hljs-keyword">true</span>) neighbor = link.getSrc();
<span class="hljs-keyword">else</span> neighbor = link.getDst();
<span class="hljs-comment">// links directed toward cnode will result in this condition</span>
<span class="hljs-keyword">if</span> (neighbor.equals(cnode)) <span class="hljs-keyword">continue</span>;
<span class="hljs-keyword">if</span> (seen.containsKey(neighbor)) <span class="hljs-keyword">continue</span>;
<span class="hljs-keyword">if</span> (linkCost == <span class="hljs-keyword">null</span> || linkCost.<span class="hljs-keyword">get</span>(link)==<span class="hljs-keyword">null</span>) w = <span class="hljs-number">1</span>;
<span class="hljs-keyword">else</span> w = linkCost.<span class="hljs-keyword">get</span>(link);
<span class="hljs-keyword">int</span> ndist = cdist + w; <span class="hljs-comment">// the weight of the link, always 1 in current version of floodlight.</span>
<span class="hljs-keyword">if</span> (ndist < cost.<span class="hljs-keyword">get</span>(neighbor)) {
cost.put(neighbor, ndist);
nexthoplinks.put(neighbor, link);
<span class="hljs-comment">//nexthopnodes.put(neighbor, cnode);</span>
NodeDist ndTemp = <span class="hljs-keyword">new</span> NodeDist(neighbor, ndist);
<span class="hljs-comment">// Remove an object that's already in there.</span>
<span class="hljs-comment">// Note that the comparison is based on only the node id,</span>
<span class="hljs-comment">// and not node id and distance.</span>
nodeq.remove(ndTemp);
<span class="hljs-comment">// add the current object to the queue.</span>
nodeq.add(ndTemp);
}
}
}
BroadcastTree ret = <span class="hljs-keyword">new</span> BroadcastTree(nexthoplinks, cost);
<span class="hljs-keyword">return</span> ret;
}</code>
第三题：设计题（SDN应用方案设计）——50分
初赛提供5种SDN应用方案（见附录），参赛队伍可以选择其中之一来搭建SDN网络，实现应用功能。并且鼓励参赛队伍对方案进行优化和创新性改进（不偏离原方案的目标）。
要求：
1.按照课程设计报告的形式，分别从选题背景介绍（选题依据，对本领域的意义），设计方案和实现方法（可以分为几个章节），验证实验设计和实验结果（初赛给出实验方案设计及仿真实验结果），结论这几个方面详述。
2.在提交的方案中需要给出实验的网络拓扑，并给出主要核心的操作步骤。对技术实现及其可行性需要作一定的论证，能给出理论分析、仿真结果等论据材料则更佳。
3.进入复赛的参赛队伍需要对开放题的方案作适当改进，并采用大赛提供的SDN平台来实现方案，使其尽量达到Demo的程度，能够现场演示说明。
4.报告文档中的必备内容：背景介绍、设计方案、实现方法、网络拓扑、优点说明、验证实验设计。文档中的可选内容：实验结果或仿真结果、理论分析、实验数据、其他补充材料。
PS：在准备第二届sdn大赛中
