软考中级-软件设计师 2022年上半年下午题真题解析：通关秘籍+避坑指南-EW帮帮网

📚 目录（快速跳转）

大题（下午题）（每题15分，共75分）

大题（下午题）（每题15分，共75分）

2022年下午题试卷：百度云盘

一、结构化分析与设计

🍔 试题一：外卖订餐系统

阅读下列说明和数据流图，回答问题 1 至问题 4，将解答填入答题纸的对应栏内。
【说明】
某公司欲开发一款外卖订餐系统，集多家外卖平台和商户为一体，为用户提供在线浏览餐品、订餐和配送等服务。该系统的主要功能是：
（1）入驻管理。用户注册；商户申请入驻，设置按时间段接单数量阅值等。系统存储商户/用户信息。
（2）餐品管理。商户对餐品的基本信息和优惠信息进行发布、修改、删除。系统存储相关信息。
（3）订餐。用户浏览商户餐单，选择餐品及数量后提交订餐请求。系统存储订餐订单。
（4）订单处理。收到订餐请求后，向外卖平台请求配送。外卖平台接到请求后发布配送单，由平台骑手接单，外卖平台根据是否有骑手接单返回接单状态。若外卖平台接单成功，系统给支付系统发送支付请求，接收支付状态。支付成功，更新订单状态为已接单，向商户发送订餐请求并由商户打印订单，给用户发送订单状态；若支付失败，更新订单状态为下单失败，向外卖平台请求取消配送，向用户发送下单失败。若系统接到外卖平台返回接单失败或超时未返回接单状态，则更新订单状态为下单失败，向用户发送下单失败。
（5）配送。商户备餐后，由骑手取餐配送给用户。送达后由用户扫描骑手出示的订单上的配送码后确认送达，订单状态更改为已送达，并发送给商户。
（6）订单评价。用户可以对订单餐品、骑手配送服务进行评价，推送给对应的商户、所在外卖平台，商户和外卖平台对用户的评价进行回复。系统存储评价。
现采用结构化方法对外卖订餐系统进行分析与设计，获得如图 1-1 所示的上下文数据
流图和图 1-2 所示的 0 层数据流图

【问题 1】（4 分）
使用说明中的词语，给出图 1-1 中的实体 E1〜E4 的名称。
【问题 2】（4 分）
使用说明中的词语，给出图 1-2 中的数据存储 D1〜D4 的名称。
【问题 3】（4 分）
根据说明和图中术语，补充图 1-2 中缺失的数据流及其起点和终点。
【问题 4】（3 分）
根据说明，采用结构化语言对“订单处理”的加工逻辑进行描述。

问题1：实体识别

图1-1中的实体E1~E4名称：

E1：商户
E2：外卖平台
E3：用户
E4：支付系统

问题2：数据存储识别

数据存储D1~D4的名称：

D1：用户/商户信息表
D2：订餐订单信息表
D3：餐品信息表
D4：评价信息表
注：
- D2：订餐订单或订单都可
- D1〜D4 数据存储的后缀为表、文件、信息表等符合题意的名称都可

问题3：缺失数据流补充

图1-2中缺失的数据流：

数据流名称	起点	终点
餐单	D3	P3
餐单	P3	E3
订餐请求	P3	P4
订单状态	P4	D2

问题4：结构化语言对“订单处理”的加工逻辑进行描述

收到订餐请求

向外卖平台请求配送。
外卖平台接到请求后发布配送单，由平台骑手接单，
外卖平台根据是否有骑手接单返回接单状态

IF 外卖平台接单成功 THEN
	 系统给支付系统发送支付请求，接收支付状态
	 IF 支付成功 THEN
		 更新订单状态为已接单，
		 向商户发送订餐请求并由商户打印订单，
		 给用户发送订单状态
	 ELSE
		 更新订单状态为下单失败，
		 向外卖平台请求取消配送，
		 向用户发送下单失败
	 ENDIF
ELSE IF 外卖平台返回接单失败或超时未返回接单状态
	 更新订单状态为下单失败，
	 向用户发送下单失败
ENDIF

二、数据库应用分析与设计

🚗 试题二：数据库应用分析

阅读下列说明，回答问题 1 至问题 4，将解答填入答题纸的对应栏内。
【说明】
为了提高接种工作，提高效率，并为了抗击疫情提供疫苗接种数据支撑，需要开发一个信息系统，下述需求完成该系统的数据库设计。
【需求分析结果】
（1）记录疫苗供应商的信息，包括供应商名称，地址和一个电话。
（2）记录接种医院的信息，包括医院名称、地址和一个电话。
（3）记录接种者个人信息，包括姓名、身份证号和一个电话。
（4）记录接种者疫苗接种信息，包括接种医院信息，被接种者信息，疫苗供应商名称和接种日期，为了提高免疫力，接种者可能需要进行多次疫苗接种，（每天最多接种一次，每次都可以在全市任意一家医院进行疫苗接种）。
【概念模型设计】
根据需求阶段收集的信息，设计的实体联系图（不完整）如图 2-1 所示。

【逻辑结构设计】
根据概念模型设计阶段完成的实体联系图，得出如下关系模式（不完整）：

【问题 1】（4 分）
根据问题描述，补充图 2-1 的实体联系图（不增加新的实体）。
【问题 2】（4 分）
根据题意，补充逻辑结构设计结果中的（a），（b）两处空缺，并标注主键和外键完整性
约束。
【问题 3】（7 分）
若医院还兼有核酸检测的业务，检测时可能需要进行多次核酸检测（每天最多检测一次），但每次都可以在全市任意一家医院进行检测。请在图 2-1 中增加“被检测者”实体及相应的属性。医院与被检测者之间的“检测”联系及必要的属性，并给出新增加的关系模式。“被检测者”实体包括姓名、身份证号、地址和一个电话。“检测”联系包括检测日期和检测结果等。

问题1：补充实体联系图（ER图）
在这里插入图片描述
联系补充：

接种：需标注为多对多联系（一个接种者可在多家医院接种，一家医院服务多个接种者）。
供货：需标注为多对多联系（一个供应商可向多家医院供货，一家医院接收多个供应商的疫苗）。

问题2：补充逻辑结构设计

第二问直接在（a）（b）两处写出属性，并标注上主键（实线）和外键（虚线）即可。
可以考虑补充供货关系的主键、外键和接种关系的主键、外键。当然可以加也可以不加
（注：这里不是必须的）

供货关系的主键：（供货商名称，医院名称）
外键：供货商名称，医院名称
接种关系的主键：（接种者身份证号，接种时间）
外键：接种者身份证号，医院名称，供应商名称

问题3：补充实体联系图（ER图）

在这里插入图片描述

被检测者（姓名，身份证号，地址，电话）

检测（医院名称，被检测者身份证号，检测日期，检测结果）

三、面向对象分析与设计

📚 试题三：人事管理系统UML设计解析

阅读下列说明和 UML 图，回答问题 1 至问题 3，将解答填入答题纸的对应栏内。
【说明】
某公司的人事部门拥有一个地址簿（AddressBook）管理系统（AddressBookSystem），用于管理公司所有员工的地址记录（PersonAddress）。员工的地址记录包括：姓名、住址、城市、省份、邮政编码以及联系电话等信息。
管理员可以完成对地址簿中地址记录的管理操作，包括：
（1）管理地址记录。根据公司的人员变动情况，对地址记录进行添加、修改、删除等
操作。
（2）排序。按照员工姓氏的字典顺序或邮政编码对地址簿中的所有记录进行排序。
（3）打印地址记录。以邮件标签的格式打印一个地址单独的地址簿。
系统会对地址记录进行管理，为便于管理，管理员在系统中为公司的不同部门建立员工的地址簿的操作，包括：
（1）创建地址簿。新建一个地址簿并保存。
（2）打开地址簿。打开一个已有的地址簿。
（3）修改地址簿。对打开的地址簿进行修改并保存。
系统将提供一个 GUI（图形用户界面）实现对地址簿的各种操作。
现采用面向对象方法分析并设计该地址簿管理系统，得到如图 3-1 所示的用例图以及图3-2 所示的类图。

【问题 1】（6 分）
根据说明中的描述，给出图 3-1 中 U1〜U6 所对应的用例名。
【问题 2】（5 分）
根据说明中的描述，给出图 3-2 中类 AddressBook 的主要属性和方法以及类
PersonAddress 的主要属性（可以使用说明中的文字）
【问题 3】（4 分）
根据说明中的描述以及图 3-1 所示的用例图，请简要说明 include 和 extend 关系的含
义是什么？

问题1：用例图识别（U1-U6类名）

根据系统描述，完整用例图如下：

U1：按照员工姓氏的字典顺序排序
U2：按邮政编码排序
U3：创建地址簿
U4：打开地址簿
U5：修改地址簿
U6：保存地址簿

U1 和 U2 可以互换，加排序和不加排序这两个字应该都没问题。

问题2：类图识别

AddressBook 的主要属性包括：部门号（名称、编码等）、姓名、住址、城市、省份、
邮政编码以及联系电话等
AddressBook 的方法包括：添加地址记录、修改地址记录、删除地址记录、排序地址记
录、打印地址记录、创建地址簿、打开地址簿、修改地址簿
PersonAddress 的主要属性包括：姓名、住址、城市、省份、邮政编码以及联系电话等
信息

问题3：include和extend 关系

include 表示包含关系，含义为：如果系统用例较多，不同的用例之间存在共同行为，
可以将这些共同行为提取出来，单独组成一个用例。当其他用例使用这个用例时，它们就构
成了包含关系。
extend 表示扩展关系，含义为：在用例的执行过程中，可能出现一些异常行为，也可能
会在不同的分支行为中选择执行，这时可将异常行为与可选分支抽象为一个单独的扩展用例，
这样扩展用例与主用例之间就构成了扩展关系。一个用例常常有多个扩展用例。

四、算法填空/设计

📚 试题四：C代码填空

阅读下列说明和 C 代码，回答问题 1 至问题 3，将解答填入答题纸的对应栏内。
【说明】
某工程计算中要完成多个矩阵相乘（链乘）的计算任务，对矩阵相乘进行以下说明。
（1）两个矩阵相乘要求第一个矩阵的列数等于第二个矩阵的行数，计算量主要由进行乘法运算的次数决定。假设采用标准的矩阵相乘算法，计算 $𝐴_{𝑛∗𝑚} ∗ 𝐵_{𝑛∗𝑝}$ ，需要𝑚 ∗ 𝑛 ∗ 𝑝次乘法运算，即时间复杂度为𝑂(𝑚 ∗ 𝑛 ∗ 𝑝)
（2）矩阵相乘满足结合律，多个矩阵相乘时不同的计算顺序会产生不同的计算量。以矩阵 $𝐴1_{5∗100}，𝐴2_{100∗8}，𝐴3_{8∗50}$ 三个矩阵相乘为例，若按(𝐴1 ∗ 𝐴2) ∗ 𝐴3计算，则需要进行5 ∗ 100 ∗ 8 + 5 ∗ 8 ∗ 50 = 6000次乘法运算，若按𝐴1 ∗ (𝐴2 ∗ 𝐴3)计算，则需要进行100 ∗ 8 ∗ 50 + 5 ∗ 100 ∗ 50 = 65000次乘法运算。
矩阵连乘问题可描述为：给定𝑛个矩阵，对较大的𝑛，可能计算的顺序数量非常庞大，用蛮力法确定计算顺序是不实际的。经过对问题进行分析，发现矩阵连乘问题具有最优子结构，即若𝐴1 ∗ 𝐴2 ∗ ⋯ ∗ 𝐴𝑛的一个最优计算顺序从第𝑘个矩阵处断开，即分为𝐴1 ∗ 𝐴2 ∗ ⋯ ∗ 𝐴𝑘和𝐴𝑘 + 1 ∗ 𝐴𝑘 + 2 ∗ ⋯ ∗ 𝐴𝑛两个子问题，则该最优解应该包含𝐴1 ∗ 𝐴2 ∗ ⋯ ∗ 𝐴𝑘的一个最优计算顺序和𝐴𝑘 + 1 ∗ 𝐴𝑘 + 2 ∗ ⋯ ∗ 𝐴𝑛的一个最优计算顺序。据此构造递归式：

其中，cost[i][j]表示𝐴𝑖 + 1 ∗ 𝐴𝑖 + 2 ∗ ⋯ ∗ 𝐴𝑗 + 1的最优计算的代价。最终需要求解 cost[0][n – 1]
【C 代码】
算法实现采用自底向上的计算过程。首先计算两个矩阵相乘的计算量，然后依次计算 3个矩阵、4 个矩阵、…、𝑛个矩阵相乘的最小计算量及最优计算顺序。下面是算法的 C 语言实现。
（1）主要变量说明
n：矩阵数、
seq[]：矩阵维数序列
cost[][]：二维数组，长度为𝑛 ∗ 𝑛，其中元素 cost[i][j]表示𝐴𝑖 + 1 ∗ 𝐴𝑖 + 2 ∗ ⋯ ∗ 𝐴𝑗 +1的最优计算的计算代价
trace[][]：二维数组，长度为𝑛 ∗ 𝑛，其中元素 trace[i][j]表示𝐴𝑖 + 1 ∗ 𝐴𝑖 + 2 ∗ ⋯ ∗𝐴𝑗 + 1的最优计算对应的划分位置，即𝑘
（2）函数 cmm
#define N 100 
int cost[N][N]; 
int trace[N][N]; 
int cmm(int n, int seq[]) { 	
	int tempCost; 	
	int tempTrace; 	
	int i, j, k, p; 	
	int temp;
	for (i = 0; i < n; i ++ ) { cost[i][i] = 0; } 		
		for (p = 1; p < n; p++ ) { 			
			for (i = 0; i < n - p; i ++ ) {
				 (1) ;
				tempCost = -1;
				for (k = i; (2) ; k ++ ) {
					temp = (3) ;
					if(tempCost == -1 || tempCost > temp) {
						tempCost = temp;
						tempTrace = k;
					}
				}
				cost[i][j] = tempCost;
				 (4) ; 			
			 } 		
		 } 	
	return cost[0][n - 1]; 
} 

【问题 1】（8 分）
根据以上说明和 C 代码，填充 C 代码中的空（1）〜（4）。
【问题 2】（4 分）
根据以上说明和 C 代码，该问题采用了（5）算法设计策略，时间复杂度为（6）。（用 O 符号表示）
【问题 3】（3 分）
考虑实例 n = 4，各个矩阵的维数：A1 为 15 * 5，A2 为 5 * 10，A3 为 10 * 20，A4 为 20 * 25，即维数序列为 15, 5, 10, 20, 25。则根据上述 C 代码得到的一个最优计算顺序为（7）（用加括号方式表示计算顺序），所需要的乘法运算次数为（8）。

问题1：代码填空（(1)~(4)）

（1）：

j = i + p;

理由：

外层循环p表示当前计算的矩阵链长度（从1到n-1）。
对于每个起始点i，终点j应为i + p（如p=1时计算相邻两个矩阵）。

（2）：

k < j

理由：

k是分割点，范围应在i和j之间（即i ≤ k < j）。
遍历所有可能的分割点以找到最小计算代价。

（3）：

cost[i][k] + cost[k+1][j] + seq[i] * seq[k+1] * seq[j+1]

理由：

递归式计算代价：
- cost[i][k]：子链A_i+1...A_k+1的最小代价。
- cost[k+1][j]：子链A_k+2...A_j+1的最小代价。
- seq[i] * seq[k+1] * seq[j+1]：当前两子链相乘的乘法次数（维度相乘）。

（4）：

trace[i][j] = tempTrace

理由：

tempTrace记录当前最优分割点k，需保存到trace[i][j]中供后续构造最优顺序使用。

问题2：算法的时间复杂度与空间复杂度

（5）：动态规划

（6）： $𝑂(𝑛^3)$

三重循环：

外层p：O(n)
中层i：O(n)
内层k：O(n)

问题2：最优计算顺序

（7）： $A 1 * （（ A 2 * A 3 ） * A 4 ）$ 或 $A 1 * （ A 2 * A 3 * A 4 ）$
或： $A 1 （（ A 2 A 3 ） A 4 ）$ 或 $A 1 （ A 2 A 3 A 4 ）$
（8）：5375

补充后完整代码：

#define N 100 
int cost[N][N]; 
int trace[N][N]; 
int cmm(int n, int seq[]) { 	
    int tempCost; 	
    int tempTrace; 	
    int i, j, k, p; 	
    int temp;
    for (i = 0; i < n; i++) { cost[i][i] = 0; } 		
    for (p = 1; p < n; p++) { 			
        for (i = 0; i < n - p; i++) {
            j = i + p;  // (1)
            tempCost = -1;
            for (k = i; k < j; k++) {  // (2)
                temp = cost[i][k] + cost[k+1][j] + seq[i] * seq[k+1] * seq[j+1];  // (3)
                if (tempCost == -1 || tempCost > temp) {
                    tempCost = temp;
                    tempTrace = k;
                }
            }
            cost[i][j] = tempCost;
            trace[i][j] = tempTrace;  // (4) 			
        } 		
    } 	
    return cost[0][n - 1]; 
}

📚 试题五：Java填空题

阅读下列说明和 Java 代码，将应填入（n）处的字句写在答题纸的对应栏内。
【说明】
在软件系统中，通常都会给用户提供取消、不确定或者错误的操作，允许将系统回复到原先的状态。现使用备忘录（Memento）模式实现该要求，得到如图 6-1 所示的类图。
Memento 包含了要被恢复的状态。Originator 创建并在 Memento 中存储状态。CareTaker 负责从 Memento 中恢复状态。
在这里插入图片描述
【Java 代码】

import java.util.*;

class Memento { 
	private String state; 
	public Memento(String state) {
		this.state = state; 
	}
 
 	public String getState() { 
 		return state; 
 	} 
 } 

class Originator { 
	private String state; 
	public void setState(String state) { 
		this.state = state; 
	} 

	public String getState() { 
		return state; 
	}
 
	public Memento saveStateToMemento() {
		return (1) ; 
	} 

	public void getStateFromMemento(Memento Memento) {
		state = (2) ; 
	} 
} 

class CareTaker {
	private List<Memento> mementoList = new ArrayList<Memento>(); 
	
	public (3) { 
		mementoList.add(state); 
	} 

	public (4) { 
		return mementoList.get(index); 
	} 
} 

class MementoPaneDemos { 
	public static void main(String[] args) {
		Originator originator = new Originator(); 
		CareTaker careTaker = new CareTaker(); 
		originator.setState("State #1");
		originator.setState("State #2"); 
		careTaker.add( (5) );
		originator.setState("State #3"); 
		careTaker.add( (6) );
		originator.setState("State #4"); 
		
		System.out.println("Current State：" + originator.getState());
		originator.getStateFromMemento(careTaker.get(0));
		System.out.println("First saved State：" + originator.getState());
		originator.getStateFromMemento(careTaker.get(1));
		System.out.println("Second saved State：" + originator.getState()); 
	} 
}

备忘录模式详解见文章

Java代码填空解析（备忘录模式实现）

（1）

return new Memento(this.state);

理由：

saveStateToMemento()方法需将当前状态保存到新的Memento对象中。
通过new Memento(state)创建包含当前状态的备忘录。

（2）

Memento.getState()

理由：

getStateFromMemento()需从备忘录恢复状态。
调用Memento对象的getState()方法获取保存的状态值。

（3）

void add(Memento state)

理由：

CareTaker类需要提供方法将Memento对象添加到列表。
方法命名为add，参数为Memento类型，无返回值（void）。

（4）

Memento get(int index)

理由：

CareTaker类需支持按索引获取备忘录。
返回类型为Memento，参数为int index。

（5）

originator.saveStateToMemento()

理由：

需要保存当前状态（State #2）到备忘录列表。
调用originator.saveStateToMemento()生成备忘录并添加到careTaker。

（6）

originator.saveStateToMemento()

理由：

同理，保存State #3到备忘录列表。
再次调用saveStateToMemento()。

完整修正代码

import java.util.*;

class Memento {
    private String state;
    public Memento(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
}

class Originator {
    private String state;
    public void setState(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
    public Memento saveStateToMemento() {
        return new Memento(this.state);  // (1)
    }
    public void getStateFromMemento(Memento Memento) {
        state = Memento.getState();  // (2)
    }
}

class CareTaker {
    private List<Memento> mementoList = new ArrayList<Memento>();
    public void add(Memento state) {  // (3)
        mementoList.add(state);
    }
    public Memento get(int index) {  // (4)
        return mementoList.get(index);
    }
}

class MementoPaneDemos {
    public static void main(String[] args) {
        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();
        originator.setState("State #1");
        originator.setState("State #2");
        careTaker.add(originator.saveStateToMemento());  // (5)
        originator.setState("State #3");
        careTaker.add(originator.saveStateToMemento());  // (6)
        originator.setState("State #4");
        System.out.println("Current State：" + originator.getState());
        originator.getStateFromMemento(careTaker.get(0));
        System.out.println("First saved State：" + originator.getState());
        originator.getStateFromMemento(careTaker.get(1));
        System.out.println("Second saved State：" + originator.getState());
    }
}

创作不易，不妨点赞、收藏、关注支持一下，各位的支持就是我创作的最大动力❤️