量子计算与QUBO模型在金融组合优化中的应用与建模实践

1. 项目概述与核心价值

看到“量子计算机在信用评分卡组合优化中的应用”这个题目，很多同学第一反应可能是懵的。量子计算机？听起来像是科幻片里的东西，怎么和我们熟悉的数学建模、金融风控扯上关系？这正是2023年MathorCup A题的巧妙之处，它把一个前沿的科技概念，拉到了一个非常具体且经典的运筹学问题上。简单来说，这道题的核心是：我们手头有一堆信用评分卡（可以理解为不同的风控规则或模型），每个卡使用成本、通过率和坏账率都不同。银行的钱（预算）和能承受的风险（坏账率上限）是有限的，我们需要从这些卡里选出一个子集，并决定每张卡分配多少贷款额度，使得最终的总利润（通过贷款利息收入减去坏账和成本）最大化。

这本质上是一个带约束的组合优化问题。传统方法，比如整数规划、启发式算法（遗传算法、模拟退火）都能做。但题目引入“量子计算机”和“QUBO”模型，是希望我们探索一种面向未来的求解思路。QUBO（二次无约束二值优化）模型是当前量子退火机和一些专用硬件（如富士通的数字退火机）直接“读懂”的模型语言。这道题与其说是考量子计算，不如说是考我们如何将一个现实的、带约束的优化问题，精确地“翻译”成QUBO这个标准形式。这考察的是数学建模中至关重要的“问题转化”与“模型抽象”能力。

对于参赛者而言，这道题的价值在于：第一，它紧跟技术热点，让你接触到量子计算在金融科技领域的应用前沿；第二，它强化了优化建模的基本功，如何建模、如何线性化、如何将约束条件转化为目标函数的一部分；第三，它提供了一个从经典算法到新兴计算范式的桥梁，即使你没有真正的量子计算机，通过模拟器或经典求解器（如Gurobi, CPLEX）求解QUBO模型，也能完整走通整个流程。接下来，我将彻底拆解这道题的解题思路、建模细节、代码实现以及那些容易踩坑的地方。

2. 问题拆解与核心思路

面对一个复杂问题，最怕的就是一头扎进细节。我们先跳出具体的数学符号，用“人话”把问题理清楚。

2.1 问题场景还原

想象你是一家银行的信贷产品经理。银行推出了10种不同的信用评分卡（编号1-10）。每种卡就像一套不同的审核标准：

• 单张卡使用成本：启用这套标准需要付出的固定费用。
• 通过率：在所有申请客户中，用这套标准能筛出多少比例的人给予放款。
• 坏账率：在那些被放款的客户中，最终有多少人赖账不还。

银行给你一笔总额为100万的资金（预算）用于放贷。你决定采用“组合策略”：不是只选一张卡，而是同时选用多张卡。对于每一张你选中的卡，你需要决定分配多少贷款额度给它。所有被选中卡的额度总和不能超过100万。同时，你还需要确保整个贷款组合的整体坏账率不能超过一个给定的上限（比如题目中可能是0.05，即5%）。

你的目标是：选择哪些卡，以及给每张选中的卡分配多少额度，才能让银行赚到最多的钱？

利润从哪里来？收入是贷款利息（假设年利率固定，比如题目中给出的24%），支出有两部分：一是坏账损失，二是使用这些评分卡的成本。

2.2 从业务逻辑到数学模型

基于以上场景，我们需要定义决策变量和数学模型。

决策变量：

1. 选择变量：x_i(i=1,2,...,10)。这是一个0-1变量。x_i = 1表示我们选择使用第i张评分卡；x_i = 0表示不使用。
2. 额度分配变量：a_i(i=1,2,...,10)。这是一个连续变量（或根据题目要求为整数），表示分配给第i张评分卡的贷款额度。显然，如果x_i = 0，那么a_i也必须为 0。

目标函数（最大化总利润）： 总利润 = 总利息收入 - 总坏账损失 - 总使用成本。

• 总利息收入 = 年利率 * 总放贷额度。
• 总坏账损失 = Σ (第i张卡的坏账率 * 分配给它的额度)。
• 总使用成本 = Σ (第i张卡的使用成本 * 是否选择它（即x_i))。

因此，目标函数可以写为：Maximize: r * Σ a_i - Σ (b_i * a_i) - Σ (c_i * x_i)其中，r是年利率，b_i是第i张卡的坏账率，c_i是第i张卡的使用成本。

约束条件：

1. 预算约束：所有分配额度之和不能超过总预算B。Σ a_i <= B。
2. 坏账率约束：整体坏账率不能超过上限β。整体坏账率 = 总坏账损失 / 总放贷额度。即Σ (b_i * a_i) / Σ a_i <= β。这是一个分式约束，需要线性化处理。
3. 逻辑关联约束：如果未选择某张卡，则不能给它分配额度。即a_i <= M * x_i。这里的M是一个很大的常数（比如总预算B），当x_i=0时，此约束强制a_i=0；当x_i=1时，此约束宽松，a_i可以取到不超过M的值。
4. 变量类型约束：x_i ∈ {0, 1}；a_i >= 0(且可能为整数)。

至此，我们得到了一个经典的混合整数线性规划（MILP）模型。用Gurobi、CPLEX等求解器可以直接求解。但题目的要求是将其转化为QUBO模型。

2.3 QUBO模型的核心思想

QUBO模型的标准形式是：Minimize y = x^T Q x，其中x是一个由0和1组成的向量，Q是一个实对称矩阵（或上三角矩阵）。

关键点在于：QUBO模型没有显式的约束条件。所有约束都必须通过“惩罚项”的方式，整合到目标函数中。原理是：如果某个解违反了约束，就在目标函数值上加上一个很大的正数（惩罚），使得这个解的目标值变差，从而在最小化过程中被淘汰。

所以，我们的核心任务就变成了两步：

1. 将连续变量a_i离散化：QUBO只能处理0-1变量。我们需要将额度分配变量a_i用一组二进制变量来表示。常见方法是二进制展开。例如，假设额度以1万元为单位，总预算100万，那么a_i的范围是0-100。我们可以用7个二进制位来表示它（因为 2^7=128 > 100）。a_i = Σ_{k=0}^{6} 2^k * z_{i,k}，其中z_{i,k}是0-1变量。
2. 将约束条件转化为惩罚项加入目标函数：将原目标“最大化利润”转化为QUBO标准的“最小化能量”。
   • 原目标：Max P = 收入 - 坏账 - 成本。
   • 转换后目标：Min H = -P + 惩罚项。
   • 惩罚项形式通常为：λ * (约束的违反量)^2。λ是一个足够大的正数（惩罚系数），确保任何违反约束的解都不是最优解。

经过离散化和惩罚项转换，我们所有的变量都变成了0-1变量(x_i 和 z_{i,k})，目标函数变成了一个二次型，从而符合QUBO模型的要求。接下来，我们就深入这两个核心步骤的细节。

3. 核心细节解析与QUBO建模实操

3.1 连续变量的二进制离散化

这是将问题适配QUBO的第一步，也是容易出错的一步。

步骤：

1. 确定离散粒度与范围：首先确定额度分配的最小单位。为了简化，我们常设最小单位是1（万元）。那么，对于第i张卡，其额度a_i是一个在[0, B]范围内的非负整数（B是总预算）。实际上，由于有约束a_i <= M * x_i，当x_i=0时，a_i=0；当x_i=1时，a_i的上限可以是B，但更精确的上限可以是B本身（因为即使只选一张卡，最多也能分到全部预算）。为保守起见，我们设定a_i的二进制表示需要能覆盖0到B。
2. 计算所需二进制位数：设所需位数为m，应满足2^m > B。对于B=100，2^7=128 > 100，所以m=7位足够。这意味着我们需要用7个0-1变量z_{i,0}, z_{i,1}, ..., z_{i,6}来表示一张卡的额度。
3. 建立映射关系：a_i = Σ_{k=0}^{m-1} 2^k * z_{i,k}。例如，如果z_{i,0}=1, z_{i,1}=0, z_{i,2}=1, 其余为0，则a_i = 2^0*1 + 2^1*0 + 2^2*1 = 1 + 0 + 4 = 5（万元）。

注意：这里有一个重要的建模技巧。a_i本身是一个变量，用二进制表示后，原目标函数和约束中所有关于a_i的线性项都会变成关于z_{i,k}的线性项，而a_i的平方项（在构造惩罚项时会出现）则会变成z_{i,k}的二次交叉项。这正是QUBO模型二次型的来源。

3.2 约束条件的惩罚项构造

这是QUBO建模最核心也最需要技巧的部分。我们需要处理三个主要约束：预算约束、坏账率约束、逻辑关联约束。关联约束在离散化后已经隐含在变量中（z_{i,k}只有在x_i=1时才可能非零，但我们需要显式处理吗？通常，更优雅的方式是将x_i本身也看作一个二进制变量，并构造惩罚项来关联x_i和z_{i,k}。但更常见的做法是，在变量定义层面就进行耦合。我们可以定义一组新的二进制变量y_{i,k}，其中i代表评分卡，k代表二进制位。但这样会丢失“选择”的信息。一个更好的方法是：将“选择”和“额度”的二进制表示合并考虑。

一种实用的变量定义方案： 我们为每张卡i定义一组二进制变量s_{i,d}。其中d的取值从0到D。d=0时，s_{i,0}就等价于原来的选择变量x_i（即是否选用该卡）。d=1,2,...,m时，s_{i,d}代表额度二进制展开的第d-1位。 那么：

• 选择变量：x_i = s_{i,0}。
• 额度变量：a_i = Σ_{k=1}^{m} 2^{k-1} * s_{i,k}。这里k从1开始，对应d=1,...,m。

这样，所有变量都是地位平等的二进制变量，共10 * (1+m)个。

现在，我们来构造惩罚项：

1. 预算约束：Σ_i a_i <= B。将其改写为等式形式以方便构造平方惩罚项：Σ_i a_i + s_{budget} = B。其中s_{budget}是一个非负的松弛变量，代表未使用的预算。松弛变量也需要用二进制表示！假设我们允许的未使用预算最多为B（全不用），那么松弛变量也需要m个二进制位来表示。设松弛变量为t_0, t_1, ..., t_{m-1}，则s_{budget} = Σ_{k=0}^{m-1} 2^k * t_k。

   • 惩罚项为：λ_1 * ( Σ_i a_i + s_{budget} - B )^2。将a_i和s_{budget}用二进制变量代入，展开后得到一个关于所有二进制变量(s_{i,d}, t_k)的二次型。

2. 坏账率约束：Σ_i (b_i * a_i) / Σ_i a_i <= β。这是一个分式约束，处理起来比较麻烦。通常将其线性化：Σ_i (b_i * a_i) <= β * Σ_i a_i。移项得：Σ_i (b_i - β) * a_i <= 0。

   • 注意，这个约束不等号右边是0。我们可以引入一个非负的松弛变量s_bad，将其变为等式：Σ_i (b_i - β) * a_i + s_bad = 0。由于左边可能为负（当整体坏账率很好时），而松弛变量非负，所以这个等式实际上强制Σ_i (b_i - β) * a_i必须<= 0，且s_bad等于其绝对值。
   • 松弛变量s_bad同样需要二进制表示。其范围需要根据数据估算。惩罚项为：λ_2 * ( Σ_i (b_i - β) * a_i + s_bad )^2。

3. 逻辑关联约束的隐含处理：在我们的变量定义下，a_i的二进制变量s_{i,k} (k>=1)与选择变量s_{i,0}之间没有天然绑定。我们需要额外添加惩罚项来强制：如果s_{i,0}=0（不选此卡），那么所有s_{i,k}=0 (k>=1)。

   • 这可以通过添加惩罚项λ_3 * Σ_i [ s_{i,0} * (1 - s_{i,0})? 不对]。更标准的做法是：对于每张卡i，添加项λ_3 * Σ_{k=1}^{m} s_{i,0} * (1 - s_{i,k})？这也不对。我们希望的是s_{i,0}=0 => s_{i,k}=0。可以构造：λ_3 * Σ_i Σ_{k=1}^{m} (s_{i,k} - s_{i,0} * s_{i,k})？这等价于λ_3 * Σ_i Σ_{k=1}^{m} s_{i,k} * (1 - s_{i,0})。当s_{i,0}=0时，此项变为λ_3 * Σ_k s_{i,k}，只要λ_3足够大，任何s_{i,k}=1都会导致巨大的惩罚，从而迫使s_{i,k}全为0。当s_{i,0}=1时，此项为0，不影响。
   • 这是一种常见的技巧，用于实现“if-then”逻辑。

最终QUBO目标函数：H = -P + λ_1 * Penalty1 + λ_2 * Penalty2 + λ_3 * Penalty3其中P = r * Σ_i a_i - Σ_i (b_i * a_i) - Σ_i (c_i * s_{i,0})是原利润函数。

我们的任务就是最小化H。将H展开，整理成关于所有二进制变量(s_{i,d}, t_k, s_bad的二进制变量)的二次型x^T Q x，就得到了QUBO矩阵Q。

3.3 惩罚系数 λ 的选择

这是一个非常关键的经验参数。如果λ太小，惩罚力度不够，求解器可能会给出一个利润很高但严重违反约束的解（不可行解）。如果λ太大，惩罚项在目标函数中占主导地位，可能会掩盖了原始利润目标的优化，导致求解器只专注于满足约束，而找不到利润较高的解。

常用策略：

1. 量级估算：λ的量级应该显著大于原始目标函数P的可能取值范围。例如，先粗略估算一下最大利润P_max的量级（比如几十万）。那么λ可以设为10 * P_max或更大。
2. 分层设置：对于不同类型的约束，可以使用不同的λ。通常，硬约束（如预算约束）的λ要比逻辑关联约束的λ设置得更大一些。
3. 试错调整：在实际求解中，这是一个需要反复调试的过程。可以先用一组较大的λ值求解，确保得到可行解。然后尝试逐步减小λ，观察解的质量（利润）是否提高，同时检查约束是否仍然满足。

实操心得：在数学建模比赛中，如果没有时间精细调参，一个稳妥的做法是将所有λ设置为一个统一的大数，例如1e6或1e8。先保证解的可行性。在论文中需要阐述你选择λ的理由和过程。

4. 模型求解与代码实现详解

得到QUBO矩阵Q后，我们就可以调用求解器了。虽然题目提及量子计算机，但在比赛中，我们通常使用经典模拟器或支持QUBO的经典求解器。

4.1 求解工具选择

1. D-Wave Ocean SDK：这是最直接的选项。即使没有真实的量子退火机，Ocean SDK也提供了模拟退火器neal.SimulatedAnnealingSampler()来求解QUBO问题。它的API简单，易于上手。
2. Gurobi / CPLEX 等MILP求解器：虽然QUBO是二次型，但Gurobi等求解器可以直接处理二次目标函数和线性约束。我们可以不将约束转化为惩罚项，而是保留为显式约束，然后使用求解器求解这个二次整数规划问题。这通常能得到更精确、更快的解。这种方法更贴近实际应用。
3. 专用QUBO求解库：如dimod（Ocean SDK的一部分）、qiskit-optimization（IBM）等，它们提供了构建和求解QUBO模型的框架。

对于MathorCup这类比赛，推荐使用Gurobi等经典求解器直接求解原MILP模型，同时额外实现QUBO转化和模拟退火求解作为对比和亮点。这样既能保证结果的质量和求解速度，又能体现你对QUBO模型的理解。

4.2 基于Gurobi的经典MILP求解代码框架

这里给出一个Python+Gurobi的求解框架。假设我们有10张卡，数据存储在列表或数组中。

import gurobipy as gp from gurobipy import GRB import numpy as np # 假设数据 num_cards = 10 # 成本c, 通过率p, 坏账率b, 这里用随机数示例，实际应从题目获取 np.random.seed(42) c = np.random.randint(50, 200, num_cards) # 使用成本 p = np.random.rand(num_cards) * 0.3 + 0.6 # 通过率 0.6~0.9 b = np.random.rand(num_cards) * 0.05 + 0.01 # 坏账率 0.01~0.06 r = 0.24 # 年利率 B = 1000000 # 总预算，单位元 beta = 0.05 # 整体坏账率上限 # 创建模型 model = gp.Model('CreditCardOpt') # 创建变量 x = model.addVars(num_cards, vtype=GRB.BINARY, name='x') # 选择变量 a = model.addVars(num_cards, vtype=GRB.CONTINUOUS, name='a') # 额度变量，可改为整数 vtype=GRB.INTEGER # 设置目标函数 # 总利润 = 利息收入 - 坏账损失 - 总成本 interest = r * gp.quicksum(a[i] for i in range(num_cards)) bad_debt = gp.quicksum(b[i] * a[i] for i in range(num_cards)) total_cost = gp.quicksum(c[i] * x[i] for i in range(num_cards)) model.setObjective(interest - bad_debt - total_cost, GRB.MAXIMIZE) # 添加约束 # 1. 预算约束 model.addConstr(gp.quicksum(a[i] for i in range(num_cards)) <= B, name='budget') # 2. 坏账率约束: sum(b_i * a_i) / sum(a_i) <= beta # 线性化: sum((b_i - beta) * a_i) <= 0 model.addConstr(gp.quicksum((b[i] - beta) * a[i] for i in range(num_cards)) <= 0, name='bad_rate') # 3. 逻辑关联约束: a_i <= B * x_i (如果x_i=0, 则a_i必须为0) M = B # 大M，可取为总预算 for i in range(num_cards): model.addConstr(a[i] <= M * x[i], name=f'logic_{i}') # 可选：额度非负约束（默认） # 求解模型 model.optimize() # 输出结果 if model.status == GRB.OPTIMAL: print(f'最优总利润: {model.objVal:.2f}') selected_cards = [] for i in range(num_cards): if x[i].X > 0.5: # 判断是否被选中 allocated = a[i].X selected_cards.append((i+1, allocated)) print(f'选中的评分卡及分配额度: {selected_cards}') else: print('未找到最优解')

这个模型清晰、直接，易于理解和实现，并且能快速得到全局最优解（对于这个规模的问题）。

4.3 基于模拟退火的QUBO求解代码框架

接下来，我们展示如何将问题转化为QUBO并用模拟退火求解。这里省略了松弛变量的二进制展开细节，仅展示核心流程。

import numpy as np import neal # D-Wave Ocean SDK 的模拟退火器 from pyqubo import Binary, Constraint, Placeholder # 用于方便地构建QUBO # 定义问题参数 (同前) num_cards = 10 c = np.random.randint(50, 200, num_cards) b = np.random.rand(num_cards) * 0.05 + 0.01 r = 0.24 B = 1000000 beta = 0.05 m = 7 # 二进制位数，覆盖0-100万（以1为单位），2^7=128 > 100 (假设以万为单位，则B=100) # 1. 定义变量 # 我们采用合并变量定义：s[i][k], i=0..9, k=0..m。k=0是选择变量，k=1..m是额度二进制位 s = [[Binary(f's_{i}_{k}') for k in range(m+1)] for i in range(num_cards)] # s[i][0]是x_i, s[i][1:]是额度位 # 2. 定义额度表达式 a_i a = [] for i in range(num_cards): # a_i = sum_{k=1}^{m} 2^{k-1} * s[i][k] a_expr = sum((2**(k-1)) * s[i][k] for k in range(1, m+1)) a.append(a_expr) # 3. 构建原目标函数 (最大化利润 -> 最小化负利润) profit = r * sum(a) - sum(b[i] * a[i] for i in range(num_cards)) - sum(c[i] * s[i][0] for i in range(num_cards)) H_obj = -profit # 要最小化 H_obj # 4. 构建约束惩罚项 lambda1 = Placeholder('lambda1') # 预算约束惩罚系数 lambda2 = Placeholder('lambda2') # 坏账率约束惩罚系数 lambda3 = Placeholder('lambda3') # 逻辑关联约束惩罚系数 # 4.1 预算约束: sum(a_i) <= B -> sum(a_i) + slack_budget = B # 为简化，这里假设额度以万为单位，B=100。我们用一个足够大的二进制表示松弛变量。 # 更严谨的做法需要引入松弛变量。此处为演示，我们采用简化惩罚项: lambda1 * (sum(a_i) - B)^2，但只惩罚超出部分。 # 标准做法应用 max(0, sum(a_i)-B)^2，但QUBO需二次型，常用 (sum(a_i) - B)^2，这会同时惩罚“使用不足”。 # 在最大化利润的驱动下，“使用不足”通常不会是最优，所以可以接受。 penalty_budget = lambda1 * (sum(a) - B)**2 # 4.2 坏账率约束: sum((b_i - beta)*a_i) <= 0 -> sum((b_i - beta)*a_i) + slack_bad = 0 # 简化惩罚项: lambda2 * (sum((b_i - beta)*a_i))**2 penalty_bad = lambda2 * (sum((b[i] - beta) * a[i] for i in range(num_cards)))**2 # 4.3 逻辑关联约束: 如果 s[i][0]=0, 则所有 s[i][k]=0 for k>=1 # 惩罚项: lambda3 * sum_i sum_{k=1}^{m} s[i][k] * (1 - s[i][0]) penalty_logic = lambda3 * sum(sum(s[i][k] * (1 - s[i][0]) for k in range(1, m+1)) for i in range(num_cards)) # 5. 构建总哈密顿量 H = H_obj + penalty_budget + penalty_bad + penalty_logic # 6. 编译模型 model = H.compile() qubo, offset = model.to_qubo(feed_dict={'lambda1': 1e8, 'lambda2': 1e8, 'lambda3': 1e6}) # 传入惩罚系数 # 7. 使用模拟退火求解 sampler = neal.SimulatedAnnealingSampler() sampleset = sampler.sample_qubo(qubo, num_reads=1000, num_sweeps=1000) # 读取次数和扫描次数 # 8. 解码并查看最优解 decoded = model.decode_sampleset(sampleset) best = min(decoded, key=lambda x: x.energy) # 能量最低的解 print(f"最低能量 (H值): {best.energy}") print(f"是否满足约束? {best.constraints(only_broken=True)}") # 检查约束违反情况 # 提取解 solution = best.sample selected = [] total_alloc = 0 for i in range(num_cards): if solution.get(f's_{i}_0', 0) == 1: # 计算分配额度 alloc = 0 for k in range(1, m+1): alloc += (2**(k-1)) * solution.get(f's_{i}_{k}', 0) selected.append((i+1, alloc)) total_alloc += alloc print(f"选中的卡及额度: {selected}") print(f"总分配额度: {total_alloc}") # 计算利润需要用到原始目标函数公式，注意这里best.energy是H值，不是利润 profit_val = - (best.energy - (best.constraints(only_broken=False).get('penalty_budget', 0) + best.constraints(only_broken=False).get('penalty_bad', 0) + best.constraints(only_broken=False).get('penalty_logic', 0))) print(f"估计利润: {profit_val}")

注意：这个QUBO示例是高度简化的，特别是约束处理部分。在实际比赛中，你需要更严谨地处理松弛变量的二进制编码，以及惩罚项的正确形式。上述代码主要用于展示流程框架。

5. 结果分析与模型对比

通过两种方法求解后，我们得到了两组解。如何分析和呈现结果，是论文获得高分的关键。

5.1 解的有效性验证

首先，必须验证解是否满足所有原始约束。

1. 可行性检查：计算选中卡的总分配额度是否超过预算B？计算整体坏账率Σ(b_i * a_i) / Σ a_i是否超过β？检查是否所有a_i > 0的卡都有x_i = 1？
2. 目标值计算：根据解中的x_i和a_i，代入原目标函数公式，重新计算总利润。确保与求解器报告的目标值一致（对于MILP求解器）或经过修正后一致（对于QUBO，需要从能量值中减去惩罚项贡献才能得到真实利润）。

5.2 经典MILP与QUBO+模拟退火对比

在论文中，你需要设计一个对比分析的环节：

结果分析要点：

• 最优解展示：用表格清晰列出两种方法得到的最优（或最佳）方案，包括每张卡是否选中、分配额度、贡献的利润等。
• 差距分析：计算QUBO方法得到的解与MILP全局最优解之间的利润差距百分比。分析差距来源：是惩罚系数设置不当导致约束轻微违反被惩罚？还是模拟退火陷入了局部最优？
• 敏感性分析（加分项）：可以分析关键参数（如利率r、坏账率上限β、预算B）变化时，最优解如何变化。这能体现模型的鲁棒性和业务洞察。
• 量子计算前景讨论：强调虽然本次使用经典模拟器，但构建的QUBO模型是兼容量子退火机的。可以讨论一旦量子计算机在精度和规模上取得突破，此类金融优化问题将如何受益。

5.3 常见问题与排查技巧实录

在实际编程和求解过程中，你肯定会遇到各种问题。以下是一些典型问题及解决思路：

1. 问题：Gurobi模型求解报错“Infeasible or unbounded”。

   • 排查：首先检查约束是否互相矛盾。最常见的原因是坏账率约束Σ (b_i - β) * a_i <= 0。如果所有卡的坏账率b_i都大于β，那么即使a_i全为0，左边也为0，约束成立。但如果有卡的b_i小于β，该项为负，约束容易满足。重点检查数据。另一个可能是大M约束中的M值不够大，导致当x_i=1时，a_i也无法取到足够大的值，与预算约束冲突。确保M >= B。
   • 解决：使用model.computeIIS()函数找出导致不可行的最小冲突约束集，然后针对性调整。

2. 问题：QUBO模拟退火得到的解总是违反约束。

   • 排查：几乎肯定是惩罚系数λ太小。模拟退火采样时，目标函数H由利润项和惩罚项组成。如果λ太小，违反约束带来的惩罚可能小于因此获得的利润提升，导致算法倾向于选择不可行解。
   • 解决：大幅度增加λ值。可以先尝试将λ1,λ2设为1e10量级。同时，检查惩罚项的形式是否正确，特别是平方项是否完整展开。

3. 问题：二进制离散化后，求解规模爆炸，模拟退火效果很差。

   • 排查：10张卡，每张卡用m+1个二进制位（例如8位），总变量数达到80个。对于模拟退火，搜索空间是2^80，这是天文数字。即便对于经典求解器，将连续变量用大量二进制位表示也会增加问题复杂度。
   • 解决：
     • 降低离散精度：不一定需要以“1万元”为单位。如果预算100万，可以以“10万元”为单位，这样B=10，只需要4个二进制位 (2^4=16>10)，变量数减半。
     • 使用经典求解器直接求解MILP：这是最实际的做法。QUBO建模重在展示思路。
     • 在论文中说明：坦诚指出由于变量规模限制，当前量子模拟器求解此类精确离散化模型有困难，但这不影响QUBO建模方法的理论正确性。未来真量子计算机可应对更大规模。

4. 问题：坏账率约束的分式处理，线性化后Σ (b_i - β) * a_i <= 0在Σ a_i = 0时似乎无意义。

   • 分析：Σ a_i = 0意味着不放贷，利润为负（因为要支付成本），显然不是最优解。在追求利润最大化的目标下，优化过程会自动避开Σ a_i = 0的区域。因此，这个线性化在数学上是等价的，在实际优化中是有效的。
   • 验证：可以在得到最优解后，验证Σ a_i > 0是否成立。

5. 问题：如何将QUBO矩阵Q可视化或输出？

   • 技巧：Q矩阵通常很大且稀疏。可以使用热力图来展示其结构。在Python中，可以用matplotlib.pyplot.imshow(qubo)来绘制。你会发现，矩阵的主对角线对应线性项，非对角线对应二次交叉项。这有助于理解变量之间的耦合关系。

最后，在论文写作中，一定要包含清晰的流程图，展示从问题分析到MILP建模，再到QUBO转化，最后到求解对比的完整逻辑链条。图表和表格是呈现结果、进行对比的有力工具。记住，数学建模竞赛比拼的不仅是解出题目，更是清晰、严谨、有深度的表达和论证能力。通过这道题，你展示的是将前沿科技概念落地到经典工程问题的能力，这是评委非常看重的。