目录
- JML知识梳理
- 部署JMLUnitNG/JMLUnit
- 按照作业梳理自己的架构设计，并特别分析迭代中对架构的重构
- 按照作业分析代码实现的bug和修复情况
- 阐述对规格撰写和理解上的心得体会
JML知识梳理
JML理论基础
关于JML的相关介绍其实课程给出的指导书就已经足够使用了，由于指导书上都有相关知识的梳理，所以这里不花费大量篇幅去书写这部分内容，只是简单提及一些东西。首先是什么是JML，课程进行，其实阅读简单的JML已经没有多大障碍了，但是对于JML的定义这种概念已经忘记的差不多了。JML是用于对Java程序进行规格化设计的一种表示语言，JML是一种行为接口规格语言，基于Larch方法创建。通过使用JML及其相关的支持工具，我们可以基于规格自动构造测试样例，并整合了SMT Solver 等工具以静态方法来检查代买实现对规格的满足情况。目前学习到的JML语言特征只是level0级别，所以只是入门啊(虽然入门就已经能够解决许多问题了)。
JML应用工具链
? JML拥有丰富的工具库，可以给用户提供JML规范检查，或者是随机测试数据生成测试。现仅举出课程中所涉及的几个.
? 1.OpenJml来检查JML的规范性
? 2.使用SMT Solver检查代码等价性
? 3.使用JMUnitNG生成数据测试代码
? 4.JMLAutoTest...
部署JMLUnitNG/JMLUnit
针对Graph接口的实现自动生成测试用例， 并结合规格对生成的测试用例和数据进行简要分析。
按照作业梳理自己的架构设计，并特别分析迭代中对架构的重构
第一次作业
第一次的架构其实很清晰了，因为最顶层的架构关系指导书已经指定了，实际上我们实现的是相关方法和细节（都是些比较底层的东西），所以这样主要提一提相关方法和细节的设计实现，顶层架构为将path抽象成一个类，并且在MyPath中实现相关path内的方法，用PathContainer，处理path间的相关操作，并存储所有的path。
path和不同点的存储：采用三HashMap的结构。
private HashMap<Path,Integer> ptoid = new HashMap<>(1024);
private HashMap<Integer,Path> idtop = new HashMap<>(1024);
private HashMap<Integer,Integer> valuepoint = new HashMap<>(102400);
复杂度分析
其中valuepoint中的key是当前路径中所出现的结点id，对应的value是该结点出现的次数。这样对于getDistinctNodeCount()方法，我们只需要输出valuepoint.size()即可。其他查询方法类似。
第二次作业
第二次作业与第一次作业的主要区别在于最短路和连通块上，而其他需求和第一次作业是一样的，所以我的第二次的架构，首先保留了第一次的架构设计（拷贝粘贴到MyGraph，MyPath类消失），在此基础上，在MyGraph类里主要实现了两个操作，一个是维护并查集，一个是用bfs求最短路。由于求最短路的问题，是一个图相关的问题，所以实现了相关的建图函数（邻接表建图）
具体来说，
//新增类 MyGraph , 删除类 MyPath
//新增方法
public int anc(int x)
public void unin(int x, int y)
public void buildufset() // 并查集
public void buildgraph() // 建图
public void buildsp() // 最短路
//bfs求最短路
public void buildspforone(int x)
{
int [] vis = new int [300];
for (int i = 0;i < 300;i++)
{
vis[i] = 0;
}
int [] node = new int [90000];
node[0] = x;
vis[node[0]] = 1;
sp[x][x] = 0;
int l = 0;
int r = 0;
while (l <= r)
{
int nd = node[l];
for (int i = 0;i < edges[nd].size();i++)
{
int nnd = edges[nd].get(i);
if (vis[nnd] == 0)
{
vis[nnd] = 1;
r++;
node[r] = nnd;
sp[x][nnd] = sp[x][nd] + 1;
}
}
l++;
}
}
//新增数据成员
private int [][]sp = new int[300][300]; // 最短路。
private int [] father = new int[300]; // 并查集
private ArrayList<Integer> [] edges = new ArrayList[300]; // 存储边
复杂度分析
由于维护了并查集，所以对于连通块的平均查询是O(1)的，显然可以接受。
对于最短路，由于第二次作业并没有票价之内的问题，所以可以使用bfs来解决无权图的最短路问题，复杂度是O(V+E),由于边数最多为4000，所以也是可以接受的。
对于floyd，由于它的复杂度是稳定在O(n^3)的，所以虽然它好写，我还是没有写,但是事实证明也能过。
第三次作业
第三次作业与第二次作业在需求上有几个主要的不同点：不满意度、票价、换乘、连通块个数。仔细分析可以发现
对于不满意度、票价、换乘都可以抽象成有权图的最短路问题。所以实际上第三次作业与第二次作业的最大区别就是
图有权了，至于连通块个数，由于第二次作业已经实现了并查集，所以直接通过n-times(unin)就得到连通块个数了。
前面说到抽象成有权图的最短路问题，是有一个问题的，如果不拆点，图中的结点同时在多条路径中，也就是说图中结点具有多种性质，朴素的建图是解决不了这种问题的。
然后想到了拆点，结果写完拆点复杂度爆炸，因为极端情况下，拆点使得点数扩大了几十倍，而对于边数更是扩大了上千倍，这种情况下使用现有的算法都面临爆炸的风险，所以当时以为凉凉了...
//拆点 + Dij 思路
public int predij(int x,int y,int model,int num,int ans)
{
for (int i = 0;i < 130;i++)
{
for (int j = 0; j < 50; j++)
{
dis[i][j] = 1070000000;
vis[i][j] = false;
}
}
dis[x][num] = 0;
int w = 0;
Queue<Edge> q = new PriorityQueue<>();
Edge e0 = new Edge(x,x,w,num);
{
q.add(e0);
for (int j = 0;j < namount;j++)
{
Edge ne;
int nn;
do {
ne = q.poll();
nn = ne.getV2();
} while (vis[nn][ne.getPid()]);
vis[nn][ne.getPid()] = true;
if (nn == y)
{
if (ans > dis[nn][ne.getPid()])
{
return dis[nn][ne.getPid()];
}
else { return ans; }
}
for (int k = 0;k < edge[nn].size();k++)
{
costs++;
Node nm = edge[nn].get(k);
w = caculw(nn,nm.getId(),ne.getPid(),nm.getPid(),model);
if (dis[nm.getId()][nm.getPid()] > dis[nn][ne.getPid()] + w)
{
dis[nm.getId()][nm.getPid()] = dis[nn][ne.getPid()] + w;
Edge e = new Edge(nn,nm.getId(),
dis[nm.getId()][nm.getPid()],nm.getPid());
q.add(e);
}
}
}
}
return ans;
}
直到看到了分层图,顿时发现了新世界，通过把path压缩成小图，然后在把各个图进行合并，最终保留下来的图满足，任意两个直接相连的结点一定属于小图，并且该边权值最小。然后通过对每一个path跑一遍最短路，再对合并之后的大图跑一遍最短路就得到了解。
//分层图 + floyd
//建小图，跑最短路
for (int i = 0;i <= 60;i++)
{
if (ridtop.containsKey(i))
{
Path p = ridtop.get(i);
clearpathedge(pathedge);
nnode.clear();
for (int j = 0;j < p.size() - 1;j++)
{
int s1 = p.getNode(j);
int s2 = p.getNode(j + 1);
if (vtoidx.containsKey(s1) == false) {
vtoidx.put(s1,++nodecnt);
idxtov.put(nodecnt,s1);
}
if (vtoidx.containsKey(s2) == false) {
vtoidx.put(s2,++nodecnt);
idxtov.put(nodecnt,s2);
}
int idx1 = vtoidx.get(s1);
int idx2 = vtoidx.get(s2);
{
pathedge[idx1][idx2] = caculw(idx1,idx2,1,1,model);
pathedge[idx2][idx1] = caculw(idx2,idx1,1,1,model);
if (!nnode.contains(idx1)) { nnode.add(idx1); }
if (!nnode.contains(idx2)) { nnode.add(idx2); }
}
}
addpathedge(model);
}
}
//采用朴素的floyd
public void floyd(int [][]a,int type)
{
for (int k = 0;k < 130;k++)
{
if (type == 0 || nnode.contains(k))
{
for (int i = 0; i < 130; i++)
{
for (int j = 0; j < 130; j++)
{
if (a[i][j] > a[i][k] + a[k][j])
{
a[i][j] = a[i][k] + a[k][j];
}
}
}
}
}
}
//最后对大图进行一次然后再跑一次floyd就OK了，^@^按照作业分析代码实现的bug和修复情况
三次作业中，强测测试和互测测试我都没有丢分（开心..）,这里主要是针对提交测评前曾经遇到的bug。
作业一bug分析
- path的hashmap实现
path是自定义的对象，所以需要去手动实现它的hashcode和equals方法，这里主要说一下hashcode一定
要保证能够复现....
- 判断大小
判断大小要注意直接减会数值溢出。
作业二bug分析
- 并查集的实现
并查集最好实现路径压缩和按秩合并，否则容易被卡成链造成tle.
- bfs的实现
bfs注意标记数组，以及bfs只能跑连通块，不连通的点的最短路无限大
- 标记数组初始化
由于有重建图操作，以及会跑多次bfs和并查集，所以需要每一次初始化好标记数组的值
作业三bug分析
- Dijkstra及Floyd的正确书写
这个算法网上都有，但是由于不熟练，debug弄了很久。
- 容器内元素是自定义对象时，重写相关方法
第三次作业中由于自定义了Edge对象，所以使用ArrrayList.contains的时候
就需要重写equals方法，要不然会按照地址进行查找。
阐述对规格撰写和理解上的心得体会
? 写规格的速度贼慢，写完之后感觉有语法错误，语法错误de完了，发现还有bug。但是，规格确实比自然语言表意清晰的多，在编写代码的时候也更明白自己到底要做些什么。
? 具体的规格撰写我的一点小心得就是，从上到下，先思考顶层功能是什么，约束是什么？然后逐层向下思考相同问题。
原文地址：https://www.cnblogs.com/backkom-buaa/p/10904461.html