Problem:
Juneau, Alaska, USA with a population of about 30,000 residents, set a record in 2023 with 1.6
million cruise passengers, hosting as many as seven large cruise ships on the busiest days, with
upwards of around 20,000 visitors.
[1] While these tourists bring in substantial revenue for the
city, on the order of $375 million,
[2] they also bring issues related to overcrowding that have the
city working to limit the number of guests. Ironically, Mendenhall Glacier, one of the premier
attractions in Juneau, has been receding, primarily due to warming temperatures caused, in part,
by overtourism. The glacier has receded the equivalent of eight football fields since 2007,
leading many locals to worry that the tourists and associated revenue will eventually disappear
with the glacier.
[3] Fortunately, Juneau has other attractions, including whale watching and rain
forests, and can maintain their status as a tourist destination, provided they can develop and enact
a plan for sustainable tourism.
Recent reports[4] have highlighted the hidden costs of tourism and the growing need to account
for and manage these costs to protect natural and cultural resources and build a sustainable
tourism industry on which numerous communities around the world depend. These hidden costs
include pressure on local infrastructure including drinking water supplies, waste management,
and an overall increased carbon footprint in tourist destinations, many of which lie in
environmentally sensitive regions. Local populations are also under pressure due to housing
supplies and costs, overcrowding, and rowdy tourists. Various measures have been enacted to
attempt to ease the burden, including increased hotel taxes, visitor fees, caps on the number of
daily visitors, and restrictions on alcohol sales and consumption. Additional revenue from taxes
have been used to support conservation, make improvements in infrastructure, and develop
community programs. While many locals that depend on tourism are concerned that additional
fees might drive tourists away and would rather see the numbers, and their businesses, grow,
many other locals are becoming disgruntled and either leaving or protesting against tourists.
• Build a model for a sustainable tourism industry in Juneau, Alaska. You may want to
consider factors such as the number of visitors, overall revenue, and measures enacted to
stabilize tourism. State clearly which factors you are optimizing, and which factors serve
as constraints. Include a plan for expenditures from any additional revenue and show how
these expenditures feed back into your model to promote sustainable tourism. Include a
sensitivity analysis and discuss which factors are most important.
• Demonstrate how your model could be adapted to another tourist destination impacted by
overtourism. How does the choice of location effect which measures will be most
important? How might you use your model to promote attractions and/or locations that
have fewer tourists to develop a better balance?
针对第一个问题，我们团队构建了一个评价模型和一个优化模型，代码如下：
评价模型：
import numpy as np

def calc_coupling_coordination(
E1, E2, S1, S2, S3, S4, S5, Eco1, Eco2, Eco3,
# 这里的 mins_maxs 只用于“标准化+计算D” (跟后面约束的 open-interval 不同)
# 可以与之前相同或适度放大即可
std_range=None
):
"""
根据题目给出的耦合协调度公式。
若需要“标准化区间”只用于 D 的计算，可以设 std_range 大一些，以免超界。
"""
# 各指标的历史极值
if std_range is None:
std_range = {
'E1': (200, 500),
'E2': (5.50, 8.00),
'S1': (7.00, 10.00),
'S2': (5.00, 9.00),
'S3': (900, 2000),
'S4': (40000, 60000),
'S5': (2.50, 4.00),
'Eco1': (50000, 70000),
'Eco2': (20, 30),
'Eco3': (0.4, 0.9)
}

text
# 简单的正向/负向标准化
def standardize(val, a_min, a_max, is_positive=True):
    v = min(max(val, a_min), a_max)  # 截断
    if a_max == a_min:
        return 0.5
    if is_positive:
        return (v - a_min) / (a_max - a_min)
    else:
        return (a_max - v) / (a_max - a_min)

# 经济子系统
e1_std = standardize(E1, std_range['E1'][0], std_range['E1'][1], True)  # 正向
e2_std = standardize(E2, std_range['E2'][0], std_range['E2'][1], True)  # 正向
U_E = 0.6 * e1_std + 0.4 * e2_std

# 社会子系统
s1_std = standardize(S1, std_range['S1'][0], std_range['S1'][1], True)
s2_std = standardize(S2, std_range['S2'][0], std_range['S2'][1], False)  # 拥堵负向
s3_std = standardize(S3, std_range['S3'][0], std_range['S3'][1], True)
s4_std = standardize(S4, std_range['S4'][0], std_range['S4'][1], True)
s5_std = standardize(S5, std_range['S5'][0], std_range['S5'][1], True)  # 就业(千人)
U_S = 0.25 * s1_std + 0.35 * s2_std + 0.15 * s3_std + 0.20 * s4_std + 0.10 * s5_std

# 生态子系统
eco1_std = standardize(Eco1, std_range['Eco1'][0], std_range['Eco1'][1], False)  # 碳足迹负向
eco2_std = standardize(Eco2, std_range['Eco2'][0], std_range['Eco2'][1], False)  # 污染负向
eco3_std = standardize(Eco3, std_range['Eco3'][0], std_range['Eco3'][1], False)  # 冰川拥挤负向
U_Eco = 0.26 * eco1_std + 0.24 * eco2_std + 0.50 * eco3_std

# 耦合度 C
product = (U_E * U_S * U_Eco) ** (1 / 3) if (U_E > 0 and U_S > 0 and U_Eco > 0) else 0.
sumU = U_E + U_S + U_Eco
C = 3. * product / sumU if sumU > 1e-12 else 0.

# 协调度 T
T_val = 0.28 * U_E + 0.28 * U_S + 0.44 * U_Eco

# 耦合协调度 D
if C > 0 and T_val > 0:
    D = np.sqrt(C * T_val)
else:
    D = 0.0
# 分级判定
if D >= 0.9:
    return D, 10, "高度协调"
elif D >= 0.8:
    return D, 9, "良好协调"
elif D >= 0.7:
    return D, 8, "中度协调"
elif D >= 0.6:
    return D, 7, "初级协调"
elif D >= 0.5:
    return D, 6, "勉强协调"
elif D >= 0.4:
    return D, 5, "临界失调"
elif D >= 0.3:
    return D, 4, "轻度失调"
elif D >= 0.2:
    return D, 3, "中度失调"
elif D >= 0.1:
    return D, 2, "严重失调"
else:
    return D, 1, "极度失调"

x_env = np.array([16.7513, 15.3352, 15.6]) # 环境保护投入（百万美元）
x_infra = np.array([50.933956, 44.106256, 45.159300]) # 基础设施投入（百万美元）
x_mkt = np.array([1.05, 0.932796, 0.8]) # 市场推广投入（百万美元）
x_soc = np.array([20.309716, 19.140700, 18.900000]) #社区项目投入（百万美元）
alpha_tax = np.array([8.0, 8.0, 8.0]) #人均税收金额 （美元）
x_div = np.array([0.29, 0.262, 0.24]) #季节分流政策力度（0~1）
T = np.array([2102.0, 2066.142, 797.152]) #旅客人数（千人/年）
C = np.array([248, 251, 245]) #旅客人均消费（美元\人）

评价指标

GovRev = np.array([346.5, 320.0, 280.0]) # 旅游收入（百万美元）
E_tour = np.array([3.16, 2.981, 2.776]) #旅游业就业人数 （千人）
F_asset = np.array([5.79, 5.8, 5.7]) #旅游企业固定资产规模（百万美元）
A_res = np.array([8.35, 8.21, 7.74]) #居民对于旅游业的态度（010）
Cong = np.array([7.65, 7.23, 6.76]) #拥堵指数（010）
A_tour = np.array([1377.3, 1311.5, 903.4]) #旅游可达性（纯数值，但计算由人数得出，基准是千人）
I_disp = np.array([55700, 54600, 53120]) #居民可支配收入（美元）
Carbon = np.array([60375.24, 62599.24, 64823.79])#碳排放 (tCO2e)
Pollution = np.array([21.57, 25.48, 22.12]) #污染指数 (越大越糟糕)
G_croud = np.array([0.635, 0.6, 0.57]) #拥挤度（0~1）

range = {
'E1': (200, 500),
'E2': (5.50, 8.00),
'S1': (7.00, 10.00),
'S2': (5.00, 9.00),
'S3': (900, 2000),
'S4': (40000, 60000),
'S5': (2.50, 4.00),
'Eco1': (50000, 70000),
'Eco2': (20, 30),
'Eco3': (0.4, 0.9)
}

定义参数名与数组的映射关系

param_map = {
"E1": GovRev,
"E2": F_asset,
"S1": A_res,
"S2": Cong,
"S3": A_tour,
"S4": I_disp,
"S5": E_tour,
"Eco1": Carbon,
"Eco2": Pollution,
"Eco3": G_croud
}

通过字典键名提取第一个元素

parameters2024 = {param: arr[0] for param, arr in param_map.items()}
parameters2023 = {param: arr[1] for param, arr in param_map.items()}
parameters2022 = {param: arr[2] for param, arr in param_map.items()}

调用函数（**parameters 解包字典参数）

D, grade, level = calc_coupling_coordination(**parameters2024)
print(f"2024年耦合协调度 D = {D:.4f}")
print(f"2024年协调等级 = {grade}级（{level}）")
D, grade, level = calc_coupling_coordination(**parameters2023)
print(f"2023年耦合协调度 D = {D:.4f}")
print(f"2023年协调等级 = {grade}级（{level}）")
D, grade, level = calc_coupling_coordination(**parameters2022)
print(f"2022年耦合协调度 D = {D:.4f}")
print(f"2022年协调等级 = {grade}级（{level}）")
优化模型：
import numpy as np
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.core.problem import ElementwiseProblem
from pymoo.optimize import minimize
from pymoo.util.dominator import Dominator
from pymoo.core.callback import Callback

=============== 1) 自定义字典序支配器 ===============

class LexicographicDominator(Dominator):
"""
字典序支配比较器：
对于两个解 A, B，它们的目标向量分别为 F_A=[f1_A,f2_A,f3_A], F_B=[f1_B,f2_B,f3_B] (都需要最小化)。
优先级顺序: f1 > f2 > f3
- 若 f1_A < f1_B 则 A 更优 (f1优先级最高),
- 若 f1_A == f1_B 再比较 f2_A,f2_B,
- 若前两者都相同再比较 f3_A,f3_B,
- 都相同则视为相等。
"""

text
def _compare(self, F_a, F_b):
    # ------ compare f1 with threshold=0.05 ------
    diff_f1 = F_a[0] - F_b[0]
    if abs(diff_f1) > 0.05:
        return -1 if diff_f1 < 0 else 1

    # => f1 相同, compare f2 with threshold=10
    diff_f2 = F_a[1] - F_b[1]
    if abs(diff_f2) > 10:
        return -1 if diff_f2 < 0 else 1

    # => f2也相同, compare f3 with threshold=1000
    diff_f3 = F_a[2] - F_b[2]
    if abs(diff_f3) > 1000:
        return -1 if diff_f3 < 0 else 1

    # => 全在阈值内 => 视为相等
    return 0

=============== 2) 定义辅助函数：耦合协调度计算 ===============

def calc_coupling_coordination(
E1, E2, S1, S2, S3, S4, S5, Eco1, Eco2, Eco3,
# 这里的 mins_maxs 只用于“标准化+计算D” (跟后面约束的 open-interval 不同)
# 可以与之前相同或适度放大即可
std_range=None
):
"""
根据题目给出的耦合协调度公式。
若需要“标准化区间”只用于 D 的计算，可以设 std_range 大一些，以免超界。
"""
if std_range is None:
std_range = {
'E1': (200, 500),
'E2': (5.50, 8.00),
'S1': (7.00, 10.00),
'S2': (5.00, 9.00),
'S3': (900, 2000),
'S4': (40000, 60000),
'S5': (2.50, 4.00),
'Eco1': (50000, 70000),
'Eco2': (20, 30),
'Eco3': (0.4, 0.9)
}

text
# 简单的正向/负向标准化
def standardize(val, a_min, a_max, is_positive=True):
    v = min(max(val, a_min), a_max)  # 截断
    if a_max == a_min:
        return 0.5
    if is_positive:
        return (v - a_min) / (a_max - a_min)
    else:
        return (a_max - v) / (a_max - a_min)

# 经济子系统
e1_std = standardize(E1, std_range['E1'][0], std_range['E1'][1], True)  # 正向
e2_std = standardize(E2, std_range['E2'][0], std_range['E2'][1], True)  # 正向
U_E = 0.6 * e1_std + 0.4 * e2_std

# 社会子系统
s1_std = standardize(S1, std_range['S1'][0], std_range['S1'][1], True)
s2_std = standardize(S2, std_range['S2'][0], std_range['S2'][1], False)  # 拥堵负向
s3_std = standardize(S3, std_range['S3'][0], std_range['S3'][1], True)
s4_std = standardize(S4, std_range['S4'][0], std_range['S4'][1], True)
s5_std = standardize(S5, std_range['S5'][0], std_range['S5'][1], True)  # 就业(千人)
U_S = 0.25 * s1_std + 0.35 * s2_std + 0.15 * s3_std + 0.20 * s4_std + 0.10 * s5_std

# 生态子系统
eco1_std = standardize(Eco1, std_range['Eco1'][0], std_range['Eco1'][1], False)  # 碳足迹负向
eco2_std = standardize(Eco2, std_range['Eco2'][0], std_range['Eco2'][1], False)  # 污染负向
eco3_std = standardize(Eco3, std_range['Eco3'][0], std_range['Eco3'][1], False)  # 冰川拥挤负向
U_Eco = 0.26 * eco1_std + 0.24 * eco2_std + 0.50 * eco3_std

# 耦合度 C
product = (U_E * U_S * U_Eco) ** (1 / 3) if (U_E > 0 and U_S > 0 and U_Eco > 0) else 0.
sumU = U_E + U_S + U_Eco
C = 3. * product / sumU if sumU > 1e-12 else 0.

# 协调度 T
T_val = 0.28 * U_E + 0.28 * U_S + 0.44 * U_Eco

# 耦合协调度 D
if C > 0 and T_val > 0:
    D = np.sqrt(C * T_val)
else:
    D = 0.
return D

=============== 3) 定义 Problem 类 ===============

class JuneauHierarchicalProblem(ElementwiseProblem):
def init(self):
# 8 个决策变量
# x_env, x_infra, x_mkt, x_soc, alpha_tax, x_div, T, C
xl = [10.0, 40.0, 0.0, 15.0, 0.0, 0.2, 500.0, 200.0]
xu = [25.0, 60.0, 10.0, 30, 10.0, 0.4, 2200.0, 260.0]

text
    # xl = [10.0, 40.0, 0.0, 15.0, 0.0, 0.0, 500.0, 200.0]
    # xu = [50.0, 100.0, 10.0, 50, 20.0, 1.0, 2200.0, 260.0]

    super().__init__(
        n_var=8,
        n_obj=3,  # 3 个目标
        n_ieq_constr=3,  # 预算约束+ D>=0.7 + 每个指标2条(上下界)
        xl=xl,
        xu=xu
    )

    # 题目所要求的开区间约束
    self.mins_maxs = {
        'E1': (200, 500),
        'E2': (5.50, 8.00),
        'S1': (7.00, 10.00),
        'S2': (5.00, 9.00),
        'S3': (900, 2000),
        'S4': (40000, 60000),
        'S5': (2.50, 4.00),
        'Eco1': (50000, 70000),
        'Eco2': (20, 30),
        'Eco3': (0.4, 0.9)
    }

    self.D_min = 0.8  # 题目要求 D >= 0.7

def _evaluate(self, x, out, *args, **kwargs):
    x_env, x_infra, x_mkt, x_soc, alpha_tax, x_div, T, C = x

    # ------------ 1) 计算各项指标 ----------------
    # 1. GovRev
    GovRev = (1000 * T * (C + alpha_tax + -218.3796)) / 1e6 + 251.9655

    # 2. E_tour
    E_tour = (58.108) + (0.000420973) * T + (-19.3388) * np.log(1 + C / (104.465)) + (33.4503) * (
            1 / (1 + alpha_tax / (-3.93095)))

    # 3. F_asset
    F_asset = (2.10818) + (-0.116903) * (x_infra / 10.0054) + (-0.331696) * (x_mkt / 1.00168) + (2.10063) * np.log(
        1 + (E_tour / 0.393086))
    # 题目中 E2 = F_asset(单位和范围需注意，这里按给定区间(5.50, 8.00)做示例)

    # 4. A_res
    A_res = (6.05431) + (0.168539) * x_div + (0.8668) * (x_env / 10.1057) - (-0.00038535) * T
    if A_res < 0:
        A_res = 0
    elif A_res > 10:
        A_res = 10

    # 5. Cong (拥堵)
    Cong = (3.74014) + (0.000416267) * T - (-0.0586679) * x_infra - (-0.160964) * x_div

    # 6. A_tour (旅游可达性)
    A_tour = (1.5081) * (((T + 100.004) / 0.000231623)**0.429576) * (1 - np.exp(-(0.45747)*(x_infra / 9.99294))) * (1 + (0.0590587)*x_div)

    # 7. I_disp (居民可支配收入)
    I_disp = (49942.2) + (0.00569082)*(T*C) + (237.171)*x_infra + (-457.361)*x_soc

    # 8. Carbon
    Carbon = (1.92453e+06) + (391.147)*((1000 * T)**-30.2898) - (-78569.9)*x_env - (805146)*np.log(1 + x_infra)

    # 9. Pollution
    Pollution = (20.7266) + (2.31625e-06)*(1000*T) - (-4.16471)*x_env - (1.44831)*x_infra - (0.0736647)*x_div

    # 10. G_croud (冰川拥挤)
    G_croud = (0.252585) + (0.00266493)*np.log(1 + T) - (-1.24836)*x_div

    # -------- 2) 计算耦合协调度 D -----------
    # S5 = E_tour(千人) => E_tour/1000
    D = calc_coupling_coordination(
        E1=GovRev,
        E2=F_asset,
        S1=A_res,
        S2=Cong,
        S3=A_tour,
        S4=I_disp,
        S5=E_tour,
        Eco1=Carbon,
        Eco2=Pollution,
        Eco3=G_croud,
    )

    # -------- 3) 目标函数：层次化 -----------
    # 第1优先级: 最大化 D => f1 = -D
    # 第2优先级: 最大化 GovRev => f2 = -GovRev
    # 第3优先级: 最小化 Carbon => f3 = Carbon
    f1 = -D
    f2 = -GovRev
    f3 = Carbon

    # -------- 4) 各种不等式约束 -----------
    g = []
    # (a) 预算约束: x_infra + x_mkt + x_env + x_soc <= GovRev
    g_budget = (x_infra + x_mkt + x_env + x_soc) - (T * alpha_tax)
    g.append(g_budget)

    # (b) D >= 0.7 => 0.7 - D <= 0
    g_D = self.D_min - D
    g.append(g_D)

    g.append(53728.75 - Carbon)

    # 将 g 转为 array 并赋值
    out["F"] = [f1, f2, f3]
    out["G"] = np.array(g)

=============== 4) 回调函数记录每代max D ===============

class MyCallback(Callback):
def init(self):
super().init()
self.gen = [] # 存储每一代编号
# 下面三个列表分别记录每代可行解的平均 D、平均 GovRev、平均 Carbon
self.mean_Ds = []
self.mean_GovRevs = []
self.mean_Carbons = []

text
def notify(self, algorithm):
    # 1) 取出当前种群的目标值F、约束值CV
    pop = algorithm.pop
    F = pop.get("F")   # shape = (pop_size, n_obj)
    CV = pop.get("CV") # shape = (pop_size, n_constraints)

    # 2) 找到所有可行解的 mask (即所有约束 <=0)
    feasible_mask = np.all(CV <= 0, axis=1)
    feasible_F = F[feasible_mask]

    # 3) 若有可行解，则计算并存储平均值；若没有，则存 NaN 或 0 以防报错
    if len(feasible_F) > 0:
        # f1 = -D, f2 = -GovRev, f3 = Carbon
        f1 = feasible_F[:, 0]  # -D
        f2 = feasible_F[:, 1]  # -GovRev
        f3 = feasible_F[:, 2]  # Carbon

        D_vals = -f1
        GovRev_vals = -f2
        Carbon_vals = f3

        mean_D = np.mean(D_vals)
        mean_GovRev = np.mean(GovRev_vals)
        mean_Carbon = np.mean(Carbon_vals)
    else:
        mean_D = np.nan
        mean_GovRev = np.nan
        mean_Carbon = np.nan

    # 4) 把结果保存进列表
    self.gen.append(algorithm.n_gen)
    self.mean_Ds.append(mean_D)
    self.mean_GovRevs.append(mean_GovRev)
    self.mean_Carbons.append(mean_Carbon)

=============== 5) 主程序：执行优化 + 可视化 ===============

if name == "main":
import matplotlib.pyplot as plt
import seaborn as sns

text
problem = JuneauHierarchicalProblem()

# 启用我们的字典序支配器
lex_dominator = LexicographicDominator()

# NSGA2 配置
algorithm = NSGA2(
    pop_size=100,
    n_offsprings=20,
    eliminate_duplicates=True,
    dominator=lex_dominator  # 关键：使用自定义字典序支配
)

callback = MyCallback()

# 优化
res = minimize(
    problem,
    algorithm,
    ("n_gen", 400),
    seed=1,
    verbose=True,
    callback=callback,
    copy_algorithm=True
)

# -- (1) 回调可视化：
gens = callback.gen  # [1, 2, 3, ..., 100]
mean_Ds = callback.mean_Ds
mean_GovRevs = callback.mean_GovRevs
mean_Carbons = callback.mean_Carbons

sns.set_style("whitegrid")

fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(12, 4), dpi=100)

# -- 左边子图：D 的可视化 --
axs[0].plot(
    gens, mean_Ds,
    color='tab:blue',
    marker='o',
    markevery=50,
    markersize=5,
    linewidth=1,
    label='Mean D'
)
axs[0].set_title("Mean D vs Generation", fontsize=12, fontweight='bold')
axs[0].set_xlabel("Generation")
axs[0].set_ylabel("Mean D")
axs[0].grid(True, alpha=0.3)

# -- 右边子图：双 Y 轴 (GovRev & Carbon) --
ax1 = axs[1]  # 左轴
ax2 = ax1.twinx()  # 右轴

# GovRev 曲线 (左 y 轴)
line1 = ax1.plot(
    gens, mean_GovRevs,
    color='tab:orange',
    marker='s',
    markevery=50,
    markersize=5,
    linewidth=1,
    label='Mean GovRev'
)
ax1.set_ylabel("Mean GovRev")
ax1.grid(True, alpha=0.3)  # 在左轴上添加网格

# Carbon 曲线 (右 y 轴)
line2 = ax2.plot(
    gens, mean_Carbons,
    color='tab:green',
    marker='^',
    markevery=50,
    markersize=5,
    linewidth=1,
    label='Mean Carbon'
)
ax2.set_ylabel("Mean Carbon")

# 设置右侧子图通用的标题和 x 轴
ax1.set_title("Mean GovRev & Carbon vs Generation", fontsize=12, fontweight='bold')
ax1.set_xlabel("Generation")

# 设置总标题，并调整布局以防止标题重叠
plt.suptitle("Evolution of Mean D, GovRev, and Carbon Each Generation",
             fontsize=14, fontweight='bold')
plt.tight_layout(rect=(0, 0, 1, 0.93))

plt.show()

# -- (2) 3D 散点图: f1, f2, f3
F = res.F

# ========== 数据增强处理 ==========
# 1. 线性插值增加数据密度
n_samples = F.shape[0]
interpolation_multiplier = 1.2  # 插值倍数，可调节
n_new = int(np.ceil(n_samples * interpolation_multiplier))

# 随机选择点对进行插值
alpha = np.random.rand(n_new, 1)  # 产生新点的插值系数
indices1 = np.random.randint(0, n_samples, n_new)
indices2 = np.random.randint(0, n_samples, n_new)
interpolated = alpha * F[indices1] + (1 - alpha) * F[indices2]

# 2. 添加高斯噪声增强分散度
noise_scale = 0.05  # 噪声强度，可调节 (0.01~0.1)
feature_std = F.std(axis=0)  # 按特征维度计算标准差
noise = np.random.randn(*interpolated.shape) * feature_std * noise_scale

# 3. 组合增强后的数据
F_augmented = np.vstack([F, interpolated + noise])  # 保留原始数据的基础上增强

# ========== 可视化部分 ==========
f1 = F_augmented[:, 0]  # =-D
f2 = F_augmented[:, 1]  # =-GovRev
f3 = F_augmented[:, 2]  # =Carbon

sns.set_style("whitegrid")  # 与 (1) 回调可视化 相同风格

fig = plt.figure(figsize=(9, 6), dpi=120)  # 适当加大尺寸、提高分辨率
ax = fig.add_subplot(111, projection='3d')

# 画3D散点
sc = ax.scatter(
    f1, f2, f3,
    c=f3,  # 颜色映射到 f1（=-D）
    cmap='viridis',  # 与前面一致
    s=50,  # 调大点尺寸
    alpha=0.85,  # 半透明，避免完全重叠
    edgecolors='k'  # 每个点加黑色边线，视觉更突出
)

# 设置坐标轴名称，并让文字稍稍远离坐标轴
ax.set_xlabel("f1 = -D", labelpad=12, fontweight='bold')
ax.set_ylabel("f2 = -GovRev", labelpad=12, fontweight='bold')
ax.set_zlabel("f3 = Carbon", labelpad=12, fontweight='bold')

# 设置标题，并给一点额外的上方留白
ax.set_title(
    "3-Objective Scatter in Final Population",
    fontsize=12, fontweight='bold', pad=15
)

# 调整视角，避免文字/点重叠
ax.view_init(elev=20, azim=45)  # elev=上下旋转, azim=水平旋转

# 坐标轴刻度大小
ax.tick_params(axis='both', which='major', labelsize=10)

# 颜色条
cbar = plt.colorbar(sc, ax=ax, shrink=0.7, pad=0.1)
cbar.set_label("Carbon", fontsize=10)

plt.tight_layout()  # 自动紧凑布局，避免元素挤在一起
plt.show()

# -- (3) 查看 可行解
X = res.X
print(f"可行解数量: {X.shape[0]}")

for i in range(10):
    x_sol = X[i]
    f1, f2, f3 = F[i]  # f1=-D, f2=-GovRev, f3=Carbon
    D_val = -f1
    GovRev_val = -f2
    Carbon_val = f3
    print(f"\n解 {i + 1}: 决策变量 x = {x_sol}")
    print(f" => D={D_val:.4f}, GovRev={GovRev_val:.4f}, Carbon={Carbon_val:.4f}")

现在，对于第二个问题，我们从南京市统计局等机构获得了相关数据，对于原模型中不适应南京市情况的（例如冰川拥挤率）等变量进行了特殊处理（剔除），然后对回归方程的参数进行重新拟合得到了一些对南京市的评价和优化结果。请资深数据分析师和数学的你，帮助我们团队分析应该怎样回答第二个问题中的“地点的选择如何影响哪个措施是最重要的？您可以如何使用您的模型来推广游客较少的景点和/或地点，以实现更好的平衡？”即“Demonstrate how your model could be adapted to another tourist destination impacted by
overtourism. How does the choice of location effect which measures will be most
important? How might you use your model to promote attractions and/or locations that
have fewer tourists to develop a better balance?”
请你给出详细的思路和理由，来指导我们团队对第二个问题的优秀回答

用中文叙述一遍