查看: 28020|回复: 4

东三省二等奖论文

[复制链接]

字体大小: 正常放大

刘李

20 主题	8 听众	141 积分

升级 20.5%

TA的每日心情

	开心 2013-2-5 00:49

签到天数: 11 天

[LV.3]偶尔看看II

电梯直达

1^#

发表于 2013-1-23 20:18 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

深圳市人口与医疗需求预测
摘要
本文是一个如何准确预测深圳市人口数量和年龄结构，并结合深圳市疾病别的患病情况，来预测深圳市未来十年医疗床位需求的问题。以概率论和数理统计为基础，我们建立了基于灰色预测和神经网络的组合模型并结合人口动力发展方程来做出比较精确的预测。
针对问题(1)，即深圳市未来十年的总人口预测，我们从《深圳市统计年鉴》上搜集的部分数据，利用灰色预测建模所需信息少、方案简单的特点和神经网络具有较强的非线性映射能力的特征，提出一种基于灰色预测和神经网络的人口预测方案。首先对人口规模的灰色预测GM（1,1）等维新息模型预测，然后再用优化的BP神经网络对GM（1,1）模型的预测值进行组合预测以作为其最终的预测值，以获得更高的预测精度。
针对问题(2)，即深圳市全市的医疗床位需求预测，我们根据历年的出生率、死亡率、总和生育率等指标，提出了人口动力发展方程，来预测深圳市未来的人口年龄结构。
针对问题(3)，即不同疾病在不同机构的床位需求，我们选取了高血压和分娩这两种具有代表性的疾病，按卫生部推荐的卫生服务需求量法进行卫生资源配置标准的测算，我们倾向于从提高和促进人群健康水平的高度和卫生资源公平与效率的角度，确定区域卫生资源的数量、质量、结构、层次、布局以及发展速度与规模，并结合了深圳市的人均可支配收入、产业结构的调整所带来的影响以及居民对不同医疗机构的选取指标来作出预测，而不是仅仅站在卫生机构生存和发展的立场上加以考虑。
关键词：GM(1,1)灰色预测  人工神经网络  遗传模拟退火算法(GASA)  卫生服务需求法

1．问题的重述
1.1  问题背景
深圳是我国经济发展最快的城市之一，30多年来，卫生事业取得了长足发展，形成了市、区及社区医疗服务系统，较好地解决了现有人口的就医问题。
根据深圳市第六次人口普查的数据，“深圳常住人口十年来年均增长3．98％，低于上一个十年（1990－2000）6．34％的增长，但仍快于全国（0．57％）、全省（1．90％）的平均水平。”
过去十年，深圳人口仍增长较快，主要原因有两个：一是人口流入量较大。十年来，深圳经济保持较高增速，提供了较多的就业岗位，吸引了大量市外人员到深圳工作和生活。深圳常住人口中，约有798万人是非户籍人口，占常住总人口的77％；二是户籍人口增长较快。十年间，深圳采取多项措施，降低了入户门槛，加快了户籍人口增长步伐。普查登记的户籍人口达251．03万人（未剔除流出市外半年以上人口），与第五次全国人口普查的121．48万人相比，10年共增加了130万人，增长1．1倍，年平均增加13万人，年平均增长7．53％。老年人口占总人口比例呈正增长趋势。因为深圳市是我国改革开放以后首批开始发展的新型城市，建市至今将近30年，人口逐渐凸显老龄化趋势。人口的增长，尤其是人口老龄化的加剧，必然导致现有的医疗资源的不足。国内外有关研究表明，人均医疗资源的需求与不同年龄的人群有关，一般情况下，60岁以上年龄组的医疗需求是60岁以下人群的3～5倍。由于老年人口是发病率和患病率最高的人群，所以老年人口的增加，意味着医疗卫生需求大幅增加。未来的医疗需求与人口结构、数量和经济发展等因素相关，合理预测能使医疗设施建设正确匹配未来人口健康保障需求，是保证深圳社会经济可持续发展的重要条件。人口预测是否科学准确，直接关系到其总体规划方案是否合理和实用。
对深圳市未来人口的准确预测，能够为深圳市医疗资源的合理、有效配置提供科学依据，这对加速推进深圳市的经济发展和全市消费有效需求的利用有着极为重要的现实意义。因此，根据已有数据，运用数学建模的方法，对深圳市人口数量和结构做出分析和预测，进而分析深圳市的医疗资源（主要是床位）的需求是一个重要问题。
1.2  问题提出
过去十年，深圳市的人口发展出现了一些新的特点，例如：老龄化进程加速，出生人口性别比持续升高，具体表现为男多女少，家庭规模偏小以及乡村人口城镇化等因素，这些都影响着深圳市人口的增长。
关于人口问题已有多方面的研究，并积累了大量数据资料。现在得到了《深圳市人口统计年鉴》上收集到的部分数据，其中包含1979至2010年的全市常住人口的数量、死亡率、生育率、男女出生比例、育龄妇女生育率的千分比( ‰) ；以及从国家卫生部公开信息网站、深圳市卫生和人口计划生育委员会网站与深圳市统计局官网上查询的其他相关数据。
根据已知数据或搜索相关文献和补充新的数据，解决以下的问题：从深圳市的实际情况和人口增长的上述特点出发，建立深圳人口增长的数学模型，并由此对深圳市未来十年人口增长的短期做出预测，并以此为依据预测深圳市不同医疗机构的资源（主要是床位数）的合理配置。
预测深圳市某一种疾病在不同类型医疗机构的床位需求就要预测该种疾病总的床位需求，而决定床位需求的就是该种疾病的患病人口，也就是深圳市该种疾病的患病率。而患病率又和人口结构有着密切的关系，因为每一种疾病都会有一个高发人群年龄段，例如，心脏病、高血压等疾病多发生在老年人中，而小儿麻痹发生在少年儿童中，因此改年龄段人口的比例严重影响着该种疾病患病率。因此，通过分析深圳市历年该种疾病患病率与人口结构的关系，回归出患病率函数，预测未来几年深圳市某种疾病患病率，并且通过预测人口求出患病人数，进而求出该种疾病的总床位需求。
同时根据高血压在老年人中的发病率较高这一现象，我们在已知高血压这一疾病的两周患病率和慢性病患病率的数据的前提下，对该疾病的床位需求进行预测是很有必要的。
2. 模型的假设
( 1) 考虑所研究的人口为常住人口；
( 2) 深圳市各区人口体质相同，即同一年度各区患病率相同，且各区相对封闭，本区人口不会外出跨区就医。
( 3) 人口数随时间变化是连续的，而且充分光滑。
( 4) 农村人口一旦迁入城镇或者城镇化, 其人口行为和特征即与城镇人口相同，即忽略城镇人口与迁入城镇人口或城镇化人口的差别.
( 5) 人口数据质量高，无误报和漏报等。
( 6) 在分析老年人口问题时，是以65岁作为老年人口的起点年龄；
( 7) 病床使用率不变，即未来的病床使用率沿用现在的标准病床使用率的数据，并且对现在病床使用率进行评价。
3．相关名词解释
人口数  指一定时点，一定地区范围内有生命的个人总和。
出生率  指在一定时期内( 通常为一年) 一定地区的出生人数与同期内平均人数( 或期中人数) 之比，用千分率表示。其计算公式为：

死亡率  指在一定时期内( 通常为一年) 一定地区的死亡人数与同期内平均人数( 或期中人数) 之比，用千分率表示。其计算公式为：

婴儿死亡率  指年内一定地区未满1岁婴儿死亡人数与同年出生的活产数之比，一般用‰表示。
人口自然增长率  是指在一定时期内( 通常为一年) 人口自然增加数( 出生人数减死亡人数) 与该时期内平均人数( 或期中人数) 之比，用千分率表示。计算公式为：

预测时期  短期( <10年)，中期( 10-25年)，长期( >25年) ；
出生人口性别比  是活产男婴数与活产女婴数的比值，通常用女婴数量为100时所对应的男婴数来表示。正常情况下，出生性别比是由生物学规律决定的，保持在103～107之间。
人口抚养比  指人口总体中处于供养年龄( 一般指15岁以下和64岁以上) 的人口与处于“经济活动”年龄( 15-64岁) 人口的比率。用百分比表示，计算公式为：

总和生育率：一定时期( 如某一年) 各年龄组妇女生育率的合计数，说明每名妇女按照某一年的各年龄组生育率度过育龄期，平均可能生育的子女数，是衡量生育水平最常用的指标之一。
总诊疗人次数: 所有诊疗工作的总人次数。诊疗人次数按挂号数统计，包括：①病人来院就诊的门诊、急诊人次；②出诊人次数；③单项健康检查及健康咨询指导人次；④未挂号就诊、本单位职工就诊及外出诊疗不收取挂号费的，按实际诊疗人次统计。患者一次就诊多次挂号，按实际诊疗次数进行统计，不包括根据医嘱进行的各项检查、治疗、处置工作量。
床位数：年底固定实有床位(非编制床位)，包括正规床、简易床、监护床、正在消毒和修理床位、因扩建或大修而停用的床位，不包括产科新生儿床、接产室待产床、库存床、观察床、临时加床和病人家属陪侍床。
出院人数：所有住院后出院的人数，包括治愈、好转、未愈、死亡及其他人数。其他人数指正常分娩、未产出院、住院经检查无病出院、未治出院及健康人进行人工流产或绝育手术后正常出院者。
实际占用总床日数：医院各科每日夜晚12点实际占用病床数(即每日夜晚12点住院人数)总和。包括实际占用的临时加床在内。病人入院后于当晚12点前死亡或因故出院的病人, 作为实际占用床位1天进行统计,同时亦应统计“出院者占用总床日数”1天,入院及出院人数各1人。
出院者占用总床日数：出院者(包括正常分娩、未产出院、住院经检查无病出院、未治出院及健康人进行人工流产或绝育手术后正常出院者)住院日数的总和。

潜在需求增长率：由于居民收入增长而导致的对医疗需求的增长，用百分比表示，计算公式为：

医院病床配置推荐标准：

病床使用率：

病床周转次数：

病床工作日：

出院者平均住院日：

居民年实际住院率：

居民两周就诊率：调查前两周内居民因病或身体不适到医疗机构就诊的人次数与调查人口数之比。
居民两周未就诊率：调查前两周内居民患病而未就诊的人次数与两周患病人次数之比。
居民两周患病率：

年平均床开放日数：

年净流入住院人数：

期望寿命  又称平均期望寿命。指0岁时的预期寿命。一般用“岁”表示。即在某一死亡水平下，已经活到岁年龄的人们平均还有可能继续存活的年岁数。
高、低限计算依据：《标准》中配置的低限为实际需求的计算结果，高限是按实际需求加上可能转化的潜在需求计算结果。
城镇居民可支配收入：将家庭总收入扣除交纳的个人所得税和个人交纳的各项社会保障支出后的收入，等于工资性收入、经营净收入、财产性收入、转移性收入之和，再减去交纳的个人所得税和个人交纳的社会保障支出。目前城镇居民可支配收入中只包括城镇居民以现金形式获得的收入。
人均可支配收入：居民可支配收入的算术平均数，即样本家庭可支配收入总额除以其家庭人口总数计算得出。
4. 模型的建立与求解
4.1  预用模型介绍
传统的人口预测方法主要有逻辑方法、常微分方程方法和动态预测方法等。这些方法在人口预测领域起到了一定的作用，但采用这些方法时都要对数据进行模型假设。由于真实模型往往是非线性的，如果在一些简单的模型假设下就进行数据模拟，常常不能达到较好的模拟效果。灰色系统理论中的灰色预测GM（1,1）模型因其所需信息少、运算方便、建模精度较高而被广泛应用于各种预测领域。近年来该模型已应用于人口规模预测，但其精度不高。人工神经网络具有高度的非线性映射能力，它能以任意精度逼近任意非线性函数，因此，它比较适合于一些复杂问题的建模。
4.1.1  GM(1,1)预测模型的基本原理
GM(1,1)灰色系统
所谓灰色系统是指既含有已知信息，又含有未知信息的系统，是由邓聚龙教授在1986年提出的。灰色理论自诞生以来，发展很快，由于它所需因素少，模型简单，特别是对于因素空间难以穷尽，运行机制尚不明确，又缺乏建立确定关系的信息系统，灰色系统理论及方法为解决此类问题提供了新的思路和有益的尝试。
灰色预测方法是根据过去及现在已知的或非确知的信息，建立一个从过去引申到将来的GM模型，从而确定系统在未来发展变化的趋势，为规划决策提供依据。在灰色预测模型中，对时间序列进行数量大小的预测，随机性被弱化了，确定性增强了。此时在生成层次上求解得到生成函数，据此建立被求序列的数列预测，其预测模型为一阶微分方程，即只有一个变量的灰色模型，记为GM(1,1)模型。
(2) GM(1,1)预测模型的基本原理
GM(1,1)模型是灰色预测的核心，它是一个单个变量预测的一阶微分方程模型，其离散时间响应函数近似呈指数规律。建立GM(1,1)模型的方法是：
设为原始非负时间序列，为累加生成序列，即
            (4-1)
GM(1,1)模型的白化微分方程为：
                                             (4-2)
式(2) 中，为待辨识参数, 亦称发展系数；为待辨识内生变量，亦称灰作用量。设待辨识向量，按最小二乘法求得式中

于是可得到灰色预测的离散时间响应函数为：
               (4-3)
为所得的累加的预测值，将预测值还原即为：
         (4-4)
4.1.2  BP神经网络模型的基本原理
4.1.2.1 神经网络的定义简介
神经网络是由多个神经元组成的广泛互连的神经网络，能够模拟生物神经系统真实世界及物体之间所做出的交互反应。人工神经网络处理信息是通过信息样本对神经网络的训练，使其具有人的大脑的记忆，辨识能力，完成名种信息处理功能，它不需要任何先验公式，就能从已有数据中自动地归纳规则，获得这些数据的内在规律，具有良好的自学习，自适应，联想记忆，并行处理和非线性形转换的能力，特别适合于因果关系复杂的非确定性推理、判断、识别和分类等问题. 对于任意一组随机的，正态的数据，都可以利用人工神经网络算法进行统计分析，做出拟合和预测。
基于误差反向传播(Back propagation)算法的多层前馈网络(Multiple-layer feedforward network, 简记为BP网络)，是目前应用最成功和广泛的人工神经网络。
4.1.2.2  BP模型的基本原理
学习过程中由信号的正向传播与误差的逆向传播两个过程组成。正向传播时，式作用于输入层，经隐含层处理后，传入误差的逆向传播阶段，将输出误差按某种子形式，通过隐含层向输入层逐层返回，并“分摊”给各层的所有单元，从而获得各层单元的参考误差或称误差信号，以作为修改各单元权值的依据。权值不断修改的过程，也就是网络学习过程。此过程一直进行到网络输出的误差准逐渐减少到可接受的程度或达到设定的学习次数为止。BP网络模型包括其输入输出模型，作用函数模型, 误差计算模型和自学习模型。
BP网络由输入层，输出层以及一个或多个隐含层节点互连而成的一种多层网，这种结构使多层前馈网络可在输入和输出间建立合适的线性或非线性关系，又不致使网络输出限制在-1和1之间。见图(4-1)

                        O          O       O             O

( 大于等于一层) W(1)…W(L)

4.1.2.3  BP神经网络的训练
BP算法通过“训练”这一事件来得到这种输入，输出间合适的线性或非线性关系。“训练”的过程可以分为向前传输和向后传输两个阶段：
1．向前传输阶段：
①从样本集中取一个样本，将输入网络；
②计算出误差测度和实际输出；
③对权重值各做一次调整，重复这个循环，直到。
2．向后传播阶段——误差传播阶段：
①计算实际输出与理想输出的差；
②用输出层的误差调整输出层权矩阵；
③ ；
④用此误差估计输出层的直接前导层的误差，再用输出层前导层误差估计更前一层的误差。如此获得所有其他各层的误差估计；
⑤并用这些估计实现对权矩阵的修改，形成将输出端表现出的误差沿着与输出信号相反的方向逐级向输出端传递的过程。
网络关于整个样本集的误差测度：

4.1.2.4  基于GASA混合学习策略的BP神经网络优化
鉴于BP算法易陷入局部极小，遗传算法（Genetic Algorithm，GA）虽有较强的全局搜索性能，但在实际应用中容易产生早熟收敛的问题，而改善其性能需增大种群数目或采用高级的进化策略，因此本文结合GA并行搜索结构和模拟退火（Simulated Annealing，SA）的概率突跳特性，提出一种神经网络权值学习的GASA混合学习策略以避免网络陷于局部极小，并将这种混合学习策略用于NARMA（p,q）递归网络和用作组合预测的多层前馈网络的学习。GASA混合策略在神经网络中学习步骤如下(流程图见图(4-2))：

图(4-2)  GASA混合策略在神经网络中学习步骤
(1)确定神经网络的结构，并用浮点数编码表示该网络。
鉴于浮点数编码更接近问题的本身，且在 v解的质量和算法效率方面均优于二进制编码，所以用基因串表示第层和层的权值向量，为第层的阈值向量，用浮点数编码来表示层BP网络。基于训练误差的单目标学习常会出现过拟合现象，影响网络的推广性，因此，采用训练样本集的训练误差和测试样本集的测试误差的综合误差指标作为网络性能的评价目标，适应度函数定义为：
     (4-5)
式中为学习误差，计算公式为

式中: 和分别为训练样本集和测试样本集中的样本数，才和，分别为训练样本或测试样本集第个样本输入对应网络输出层第个结点的期望输出和实际输出。
选择操作是按照优胜劣汰、适者生存的原则选择交配个体以产生子个体的过程。本文采用截断选择法，在该方法中，个体按适应度由大到小排序，只有截断阈值之上的优秀个体能够被选择作为父个体，在该阈值之下的个体不能产生子个体。
浮点数编码遗传算法(float-encoding genetic algorithm, FGA)的常用交叉算子有多种，如简单交叉、算术交叉、启发交叉、混合交叉和平坦交叉等。本文采用混合交叉算子。设，在交叉算子作用下产生两个新个体和，混合交叉算子是对的每个分量对，设，在区间中按均匀分布选择两个随机数作为，这里为事先给定的常数，一般取。
FGA常用变异算子有均匀变异、边界变异和高斯变异等。本文采用均匀变异的。
(2)确定种群大小、进化最大代数、选择操作时的淘汰率、变异概率、初温和退温速率，初始化种群，令。
(3)对中的各个个体进行SA搜索：
(3.1)利用SA状态产生函数产生新的个体。
(3.2)计算新、旧个体的综合误差之差。
(3.3)计算接受概率。
(3.4) 若，用新个体取代旧个体；否则，旧个体不变。
(4) 对中的个体按适应度由大到小进行排序，然后以淘汰率淘汰掉适应度值低的个体，被淘汰掉的个体数为，再将未被淘汰掉的优良个体保留到下一代种群中。
(5) 次从的优良个体中随机选择两个个体进行交叉操作，每次产生一个新个体填补到中以保持种群规模不变。
(6) 以变异概率对步骤(5)产生的新个体进行变异操作,至此产生种群。利用退温函数进行退温，交换训练样本集和测试样本集。
(7)若最优个体的综合误差满足要求精度或已达到进化最大代数，则终止算法并输出结果；否则，令，转到步骤(3)
4.2  针对问题（1）
4.2.1 预测深圳是未来十年全市总人口所采用模型----GM(1,1)模型和BP神经网络模型的组合预测
尽管目前时序预测的方法很多，但它们的应用条件、建模机理各异，都存在一定的局限，因此，在实际应用中传统的单一预测方法难以获得较为满意的预测结果。如果将各种预测方法进行组合，充分利用各自包含的一些有用的信息，扬长避短，将能产生较好的预测效果。自J.M.Bates和C.W.Granger(1969)首次提出组合预测以来，组合预测的方法和应用被广泛研究，但这些方法的大部分都侧重于预测误差方法的最小。文献 [1]用各种预测方法如平均值法、递归最小二乘法、模糊逻辑系统、神经网络法等对煤气日用量的无隐含层前馈网络和单隐层前馈网络的预测值进行了组合预测的研究，研究结果表明神经网络的组合预测效果优于其它方法。鉴于此，本文将人口规模的GM（1,1）等维新息模型的预测值和BP神经网络进行组合预测并求出其最终的预测值。用于人口预测的灰色预测和神经网络的组合模型的基本方法与步骤为：
(1)以人口的历史统计数据建立GM(1,1)等维数为的等维新息模型，其灰色预测值为。
(2)将灰色预测值作为用于组合预测的多层前馈网络的输入，其对应的实际值作为该网络的输出构成匹配对( , )然后将这些匹配对分为两部分，A部分用于网络的训练，B部分用于测试该网络的性能。
(3)如同递归网络，用GASA混合学习策略对A部分样本进行组合预测网络FNN的学习，然后作一步预测，从而得到人口规模的最终预测值。
4.2.2  未来十年深圳市总人口预测结果分析

表4-1  2011-2020年深圳市总人口预测

单位人口预测值（万人）
2011 1083.018
2012 1131.64
2013 1182.52
2014 1235.3
2015 1289.743
2016 1345.691
2017 1403.042
2018 1461.729
2019 1521.705
2020 1582.941

图(4-3)深圳市未来十年总人口预测图
按此预测，从以上图表中可以知道深圳市人口增长的中短期趋势为：深圳市人口自然增长率继续保持平稳下降，人口总量在中短期内继续增长，增速较为平稳。人口总量在未来10年还将净增500万人左右，总人口将于2020年达到1582.941万人。
单独的GM(1,1)模型和神经网络模型都能非常精确的预测出在短期内深圳市未来人口总数，在中期预测中，也能较好的反映出人口变化趋势。在长期预测时，GM(1,1)的预测数据偏差非常大，神经网络虽然变化趋势较符合深圳市未来人口变化情况，但偏差还是较大。而组合模型在这三个时期内，都能够很好的预测出深圳市未来人口总量的及其变化情况，显然组合模型的预测效果最佳。关于GM(1,1)长期预测的局限性将在模型评价中讨论。
4.3  针对问题（2）
4.3.1 预测深圳市未来十年人口年龄结构所采用模型----人口发展动力方程（部分指标值的预测见附表1）
4.3.1.1  人口的年龄结构
将人口按年龄大小逐年分成个年龄组，模型要讨论在不同时间人口的年龄分布，对时间也加以离散化，其单位与年龄组的间隔相同。时间离散化为 .设在时间段第年龄组的人口总数为，定义向量，根据分年龄的人口结构递推公式进行预测，模型的数学表达如下：

其中：

式中：为第年常住人口0岁出生婴儿数，为第年的第岁的常住人口数，为第年到第年迁入的总人口，为第年到第年迁入的岁人口，  为第年容纳的最大迁入人口，为第t年到第t+1年的迁出的总人口，为第年到第年的迁出的岁的人口，为年的迁入率（在一定时期内可以认为不变），为年的迁出率（在一定时期内可以认为不变），为第年常住人口出生婴儿当年死亡率，为常住人口中妇女总和生育率，即社会人中平均意义下一个妇女在整个育龄时期的生育总数（，即为生育年龄的上下限），为常住人口中第年年龄为的女性性别比，为第年第岁的常住人口死亡率，表示生育模式，反映某一地区某一个育龄妇女生育状态分布；表示迁入模式，反映某一地区迁入人口随迁入年龄的状态分布，表示迁出模式，反映某一地区迁出人口随迁出年龄的状态分布。
假定一：
三个模式在一定时期内稳定，生育模式采取对数正态分布，迁入模式和迁出模式均采取分布，
即：

其中；取总和生育率，为最低生育年龄，的取值范围为(1.7,2.5)，的取值范围为(0,1)，在本文中取2.4，取0.5，拟合效果比较理想。
其中期望生育年龄为，经计算等于26.49，比较符合实际。

其中为迁入峰值年龄，为迁入人群年龄下限，为可控变量，根据拟合可以得出其值约为0.67；

其中为迁出峰值年龄，为迁出人群年龄下限，为可控变量，根据拟合可以得出其值约为1.4；
假定二：
迁入人口的阻尼程度与总人口的阻尼程度成正比；迁出人口的逆阻尼程度与总人口的阻尼程度成正比。
即：

人口的阻尼程度利用经验公式：
;
4.3.1.2  人口的死亡率
人口的死亡率的计算公式为：

其中死亡率表示第岁的人口所占总人口的比例，表示第岁人口的分年龄层死亡率。
其中分年龄的死亡模式计算公式：

因而，预测未来十年的人口分年龄死亡模式为：

在这里，
(1)我们假定环境因子不变，设定为1；
(2)收入因子的计算公式为：，其中人均可支配收入的增长速率以最近五年的平均速率来计算。用反衰减因子法预测未来的人均可支配收入。即：

则，未来的人均可支配收入的计算公式为：
(3)居民健康水平：
4.3.1.3  人口的性别比
性别比的预测公式：

其中第三产业的增长速率数据可以从深圳市国民经济和社会发展统计公报获知。
4.3.1.4  各项预测指标调整的方法
1．先由已知的各指标值的数据，算出其均值和标准差，分别记为记为，我们定义一个相似随机因子，计算公式为。
2．对已预测出的数据进行随机操作：记以预测数的数据所组成的数列为，
①求出已预测出的数据的均值和标准差，分别记为和；
②调整后的数列为，则，调整后的预测值所组成的数列的计算公式为：

4.3.2 未来十年深圳市人口年龄结构预测结果分析
4.3.2.1  深圳市年龄结构变化趋势

图(4-4)  深圳市未来十年年龄别人口预测图

图(4-4-1)  深圳市未来十年中青年人口发展趋势

图(4-4-2)  深圳市未来十年老年人口发展趋势
按此预测，有以上图表可知，深圳市未来十年年龄别人口的发展趋势是：中青年的流动性大，人口结构相对不稳定，易受外部影响（政府的调整、经济的吸引力等）；而老年人口在缓慢增加，导致老龄化在平稳中逐年加剧。
但是人口老龄化将导致抚养比不断提高，尤其是乡老年人口变化显著，老龄化速度仅仅是深圳市在10年就增加了0.7个百分点。
老年人口比重的不断提高和老年人口绝对数的大量增加，在如何搞好老年人口的衣食住行和老有所养、老有所乐、老有所为等方面是社会不容忽视的问题。
4.3.2.2  深圳市人口分年龄死亡率变化
人口死亡水平是造成人口数量和结构变化的重要因素之一，随着深圳市经济的迅速发展和医疗卫生条件的进一步改善，深圳市人口的健康水平有了明显改善, 人口的死亡率总体上较低。

图(4-5)  深圳市未来十年人口年龄别死亡率变化预测图

图(4-5-1)  深圳市未来十年中青年人口死亡率变化预测图

图(4-5-2)  深圳市未来十年老年人口死亡率变化预测图
按此预测，由以上图表可知，深圳市未来十年青少年的死亡率在逐年下降，这与居民生活水平的提高、生活质量的改善有关，从而导致患病率降低；小中青年和青壮年的死亡率逐年递增，与外来务工人员的不断流入，和从事的工作（体力、高风险等）性质有关。
在刚进入老年时期时，死亡率不增反降，与居民的生活水平的提高和刚退休生活压力小有关，而后上升幅度较大，是由于居民的年龄增大和身体素质的下降。
4.3.2.3  深圳市性别比与第三产业关系

图(4-6)  深圳市人口性别比与第三产业关系图
图中居上的一条线代表人口性别比，居下的一条线表示第三产业的增长速度，根据深圳市国民经济和社会发展统计公报上的数据，在近十年中深圳市产业结构发生着巨大的改变，第一产业的增长速率在逐年减少，而第二、第三产业的增长速率却在逐年增加，因而大量的外来务工人员进入深圳市，导致了深圳市性别比、人口结构、分年龄的死亡模式发生了变化。
由图可以知道，第三产业的发展在一定程度上影响性别比（即模型中性别比与第三产业的关系式）。
4.3.3  预测深圳市全市医疗床位需求----卫生服务需求量法
在如何合理配置医疗卫生资源的问题上，有两点大家是有共识的：第一要以区域内居民的卫生服务需要和需求为基础；第二，规划是面向未来的，因此必须以某种方式较准确地反映未来的需要和需求。预测未来医疗服务的需要和需求的变化，不能忽略了一些重要的社会经济指标，多个社会经济因素对卫生服务需要和需求产生影响，这些因素包括人口(数量、年龄结构、性别等)、收入、价格、疾病谱及医疗保障制度等等。因此，在制订医疗资源配置规划时，必须对这些因素的未来状态做一个恰当的估计，并实实在在地纳入影响卫生服务需要和需求的计量中去。
同时在分析本市医疗资源历史发展及现有状况的基础上，考虑病人的流向、潜在需求、流动人口及人口增长等因素的影响，来进一步确定医疗资源的数量、结构、布局以及发展速度与规模。
4.3.3.1  卫生服务需求量法基本公式
医院床位需求量：
   医院床位需要量：

4.3.4  未来十年深圳市全市医疗床位需求预测结果分析
表4-2  2011-2020年深圳市全市医疗床位需求预测
单位全市床位需求（张）
2011 33949
2012 39063
2013 45795
2014 55200
2015 69759
2016 92470
2017 128464
2018 191571
2019 310318
2020 498966

图(4-7)深圳市未来十年全市医疗床位需求预测图
4.4  针对问题（3）
4.4.1  深圳市不同医疗机构的需求权重
通过综合患者偏好、医院规模（主要以床位数据为准）、医师比例等因素，求出了综合医院、专科医院以及街道医院三种医院床位需求权重。
表4-3  不同医疗机构床位需求权重
综合医院专科医院街道医院
消费者偏好 58% 33% 9%
医院规模 55% 40% 5%
医师比例 60% 33% 7%
权值 0.58 0.35 0.07
4.4.2  疾病别的床位需求预测
4.4.2.1  因病住院人数的计算
设，利用衰减因子法：，则对于深圳市未来的，有；其中，住院人数计算公式为：


图(4-8)住院人数与就诊人数的比值随年份的变化趋势图
4.4.2.2  因患高血压所需的床位数
针对深圳市老龄化的日趋严重，以及高血压在老年人口中的高发病率这一现状，随着经济的增长和社会福利制度的完善，老年人患病后的就诊需求会更加迫切，因此，我们预测仅仅因为高血压这一疾病深圳市全市就要增加的床位数总数，其计算公式：

4.4.2.3  因妊娠、分娩和产褥期小计所需的床位数
根据深圳市国民经济和社会发展统计公报的数据，第三产业的增长速率在逐年增加，因而人口性别比也在变化，同时根据深圳市卫生统计年鉴(数据来源于深圳市卫生与人口计划生育委员会网站)，在深圳市医院住院病人疾病顺位里，从2003年—2010年妊娠、分娩和产褥期小计的比重连续8年排在第一位，所以对妊娠、分娩和产褥期小计的床位需求预测是很有必要的，其计算公式为：

4.4.3 高血压在不同的医疗机构的床位需求的预测结果
表4-4  2011-2020年高血压在不同医疗机构的床位预测
单位高血压所需床位数（张）综合医院专科医院街道医院
2011 99.986 57.99 34.99 6.99
2012 100.054 58.03 35.02 7.00
2013 100.133 58.08 35.05 7.01
2014 100.212 58.12 35.07 7.015
2015 100.290 58.16 35.10 7.02
2016 100.369 58.21 35.13 7.025
2017 100.457 58.26 35.16 7.03
2018 100.546 58.31 35.19 7.038
2019 100.634 58.36 35.22 7.04
2020 100.722 58.41 35.25 7.05
4.4.4 妊娠、分娩和产褥期小计在不同的医疗机构的床位需求的预测结果
表4-5  2011-2020年分娩在不同医疗机构的床位预测
单位分娩所需床位数（张）综合医院专科医院街道医院
2011 7276 4220.1 2546.6 509.3
2012 7357 4266.9 2574.8 515.0
2013 7297 4232.1 2553.8 510.8
2014 7266 4214.1 2543.0 508.6
2015 7127 4133.7 2494.5 498.9
2016 6966 4040.4 2438.2 487.6
2017 7181 4165.1 2513.4 502.7
2018 7181 4165.1 2513.4 502.7
2019 7441 4315.8 2604.4 520.9
2020 10681 6194.9 3738.3 747.7
5. 模型检验
5.1  人口预测
现有深圳市1979—2010年的人口总数,、出生率和死亡率数据。用C语言编写的灰色GM(1,1)模型和改进的BP神经网络模型的程序，首先根据深圳市1979-2009年的数据，利用此组合模型进行预测，将所预测得到的2010年深圳市人口总数与已有数据进行比较，并验证组合模型的短期预测精度。
通过计算，可知GM(1,1)预测的数据与实际数值的绝对误差大于组合模型得到的仿真数据与实际数值的绝对误差，相对误差大于组合模型得到的仿真数据与实际数值的相对误差，均方差大于组合模型得到的仿真数据与实际数值的均方差，由此可见此组合模型在人口总数预测方面仿真数据的精确性较单独的GM(1,1)模型要高得多。
5.2  床位数量预测
5.2.1  卫生服务需求量法的精度和优势
预测未来医疗服务的需要和需求的变化，不能忽略了一些重要的社会经济指标。前面的分析己经证明，多个社会经济因素对卫生服务需要和需求产生影响，这些因素包括人口(数量、年龄结构、性别等)、收入、价格、疾病谱及医疗保障制度等等。因此，在制订医疗资源配置规划时，我们对这些因素的未来状态做一个恰当的估计，并实实在在地纳入影响卫生服务需要和需求的计量中去。同时在分析本市医疗资源历史发展及现有状况的基础上，考虑病人的流向、潜在需求、流动人口及人口增长等因素的影响，来进一步确定医疗资源的数量、结构、布局以及发展速度与规模，这样结合了实际情况的预测值比仅仅依靠历年床位数据所得出的预测值更可行，更贴合实际情况。
5.2.2  评价医院床位供需平衡状况
床位供需平衡评价采用供需比方法，即将当地实际医院床位供给数与医院床位需要（需求）数进行对比，求出比值再进行评价。
(1) 供需比值在范围内，为供需平衡；
(2) 供需比值在范围外，但在范围外，为基本平衡；
(3) 供需比值超出范围为供需不平衡，比值为短缺或不足，比值为过剩。
5.2.3  对医疗机构的划分
在这个问题上，我们依据经济学和消费心理学中的相关知识，综合患者偏好、医院规模、医师比例这三个指标求出不同医疗机构的需求权重，而不是根据医院科室的设置来划分，这样的处理更贴合居民看病消费的实际需求。
6. 模型的评价和推广
6.1  灰色GM(1,1) 模型评价及推广
6.1.1  灰色GM(1,1)模型优点
灰色GM(1,1)预测模型在计算过程中主要以矩阵为主，它与C语言的结合解决了它在计算中的问题。由C语言编制的灰色预测程序简单实用，容易操作，预测精度较高。
6.1.2  灰色GM(1,1)模型的缺点
该模型是指运用曲线拟合和灰色系统理论对我国人口发展进行预测的方法，因此它对历史数据有很强的依赖性，而且GM (1,1)的模型没有考虑各个因素之间的联系。因此，误差偏大，尤其是对中长期预测，例如对中国人口总数变化情况做长期预测时，误差偏大，脱离实际。下面我们来讨论GM(1,1)模型的适用范围。
GM(1,1)模型的白化微分方程：

其中为发展系数，
有命题当GM(1,1)发展系数时,GM(1,1)模型无意义。
通过分析，可得下述结论：
当时，GM(1,1)可用于中长期预测；
当时，GM(1,1)可用于短期预测，中长期预测慎用；
当时，GM(1,1)作短期预测应十分谨慎；
当时，应采用残差修正GM(1,1)；
当时，不宜采用GM(1,1)；
在对深圳市人口总数变化情况的预测过程中， =－0.040597，因此可做短期和中长期的预测。
如果要考虑到多因素的联系和影响，此时我们不妨建立GM( 1, n) 模型。 GM( 1, N) 模型能模拟系统发展的动态过程，不但吸收了传统的灰色模型的建立，而且建立了多中改进的灰色模型，提高了预测精度。具体参考[5]
6.2  BP神经网络模型的优化、评价及推广
6.2.1  学习因子h 的优化
采用变步长法根据输出误差大小自动调整学习因子，来减少迭代次数和加快收敛速度。
，为调整步长，在0～1之间取值
6.2.2  隐含层节点数的优化
  隐含层节点数的多少对网络性能的影响较大，当隐含层节点数太多时，会导致网络学习时间过长，甚至不能收敛；而当隐含层节点数过小时，网络的容错能力差。利用逐步回归分析法并进行参数的显著性检验来动态删除一些线形相关的隐节点，节点删除标准：当由该节点出发指向下一层节点的所有权值和阈值均落于死区（通常取±0.1、±0.05等区间）之中，则该节点可删除。最佳隐含层节点数可参考下面公式计算：

表示输入节点数；表示输出节点数；表示介于1～10的常数。
6.2.3  输入和输出神经元的确定
利用多元回归分析法对神经网络的输入参数进行处理，删除相关性强的输入参数，来减少输入节点数。
6.2.4  运用BP神经网络进行人口预测的可行性
一个好的人口预测模型首先应符合人口基本理论和数学建模要求，这是选择模型的关键。其次要保证模型数据可得，一致和可比性，在数据预测检验阶段应充分拟合原始数据，特别是有波动的数据，因为波动性数据往往蕴藏了系统重要信息。具有P个输入，Q个输出的BP网络可看作P维欧氏空间到Q维欧氏空间的一个非线性映射，含一个隐含层的BP网络可以逼近任何连续函数。BP网络的非线性映射与人口非线性特征是相近的，对于未知的人口动力学系统可通过神经网络来学习系统的表征量并进行预测，已有定理从数学上保证了网络用于时间序列预测的可行性。网络的输入向量和结构参数可由相空间重构技术予以确定，同时BP网络的动态学习能力对人口波动性数据具有较强的识别和拟合能力，克服了以往人口预测模型剔除奇异值或划分阶段处理的缺陷。因此从模型映射性质, 输入变量的选择和波动性数据拟合等方面表明BP神经网络模型用于人口预测是可行的。用神经网络对人口历史数据进行分析拟合，是人口预测的有效方法。与传统的人口预测方法相比，将基于BP神经网络的时间序列预测方法用于人口预测，避免了繁琐的常规建模过程。神经网络模型良好的适应和自学习能力，使预测系统计算简单、灵活，运用计算机强大的组合能力，可以更好地实现人口分类预测和管理，大大提高人口预测效率和预测精度。
6.2.5  BP神经网络的不足：
BP神经网络需要大量的样本数据用来训练和测试，当样本数量不够时，预测的误偏差很大。
针对这些问题，我们提出GM(1,1)和BP神经网络的组合模型，这样利用灰色系统理论具有所需要的样本数据少，原理简单，运算方便，短期预测精度高等优点，也发挥了神经网络并行计算，容错能力强，自适应能力强等优点。
6.3  供需比评价法对医院床位的预测的优缺点
6.3.1  供需评价法对医院床位的预测的优势
卫生服务的公益福利性质也决定了不可能使市场机制在卫生资源的配置中起基础性作用。因为在医疗卫生领域市场机制的局限性突出表现在这个机制不能解决医疗卫生服务分配不公的问题，不能解决人人享有基本医疗保健问题，这个局限性是市场固有的，是无法克服的。所以在医疗卫生领域，资源的配置只有在政府的宏观调控下，辅以市场调节，二者有机结合的资源配置方式。宏观调控的基本内容就是根据医疗需求，对医疗资源的总量、功能、结构和布局进行调控，合理配置医疗资源，保持总供给与总需求的基本平衡。
影响床位数的因素多而复杂，如人口数、人口年龄结构、经济水平、人均收入水平、居民健康状况、居民卫生服务需求、卫生服务利用、卫生服务能力等。其中，居民健康状况、卫生服务需求和利用是综合性指标，代表着医疗卫生服务的工作量，从而决定着床位的客观需要量。本文利用卫生服务调查中居民健康状况、居民卫生服务需要(需求)与利用以及卫生统计年鉴中卫生服务利用效率等数据，对深圳市全市床位的需要(需求)量进行测算，然后与实际床位供给数进行比较，求出供需比值，进行供需评价。此法具有以下的优点：
①按照深圳市居民的实际需要(需求)量来测算床位需要(需求)量，科学性和实用性较好；
②方法简单可行，可操作性强；
③结果是定量的而非定性的，在床位资源供需平衡状态评价方面，提供了一个客观的量化标准，为总量控制提供依据。
6.3.2  供需评价法对医院床位的预测的劣势
本法仅限于总量评价，而无法对各级各类医院床位的供需平衡状况进行客观的评价。
6.3.3  对医疗资源预测的评价和改进
该模型考虑的是常住人口，而根据深圳市的人口现状，有大量的外来务工人员在深圳市务工，因而可以对该模型做进一步的改进，即把深圳市人口的中非户籍人口远远高于户籍人口这一现状考虑进去，并考虑流动人口的经济水平和实际就诊需求，对医疗需求的预测会更完善。
7. 我们的一些建议
1.今后20年前后我国人口趋于年青化的发展态势，之后人口老年化的趋势逐渐显著，且成年群体的负担会越来越重，深圳市也不例外。鉴于此, 要加强发展基层的养老保险等社会保障事业，现在的年轻群体可以投入这样的组织来保障老年的生活，同时也减轻年轻一代的负担。
2.继续实施计划生育政策，促使人口健康、稳定发展，并利用教育，宣传等形式来。引导男女性别比的协调发展，如果按照上述的态势发展，势必会造成一系列严重的社会问题.
3.发挥深圳市当地的地区优势，合理调整甚至是的产业结构，创造就业机会，发展自己的经济，活跃市场，给上述的群体创造更多的就业和再就业机会。
结语：
此组合模型将灰色预测与神经网络相结合，充分利用了灰色预测建模所需信息少、方法简单的特点和神经网络具有较强的非线性映射能力的特性，采用多层前馈网络预测模型和灰色预测GM(1,1)等维新息模型的预测值进行组合预测，同时针对BP算法易陷入局部极小的缺陷和GA易产生早熟收敛的问题，提出了一种GASA混合策略的神经网络权值学习方法，并将这种混合策略应用于BP神经网络中进行学习，从而提高了预测的精度。此组合模型简单、实用、特别是在原始数据非常有限的情况下，可以得到相当精度的拟合数据，并能得到可靠的预测数据。
由于神经网络的功能之强大, 型式之多样，若能将其它网络形式同灰色预测相结合，则有可能进一步提高预测精度，并能在人口预测方面发挥更大的作用。
在参考宋健人口发展方程的基础上，我们提出了更切合深圳市人口特色的人口动力发展方程，在预测出深圳市未来十年的总人口的基础上，预测出了未来十年的人口结构，并基于此提出了生育模式和死亡模式。
在预测床位的数量这一问题上，我们结合了深圳市的产业结构发展特点、外来务工人员较多、非户籍人口远远大于户籍人口的特点、深圳市人均可支配收入、居民健康状况、卫生服务需求等种种因素，以医疗服务需求法来预测深圳市未来十年全市的床位需要量、需求量以及疾病别的床位需求量，得出的数据比单纯使用历年数据所预测出的结果要精确得多。
在医疗资源稀缺的情况下，对于医疗资源配置的方式主要包括一下三种：以需求为基础的模式，以供给为基础的模式，以供给和需求相结合为基础的模式。但是随着人类社会的发展和进步、疾病谱的改变、医学模式的转变和人均期望寿命的延长等等，如何更好地体现医疗服务的公平性和可及性以及更好地配置医疗资源成为困扰宏观调控的又一课题。
8. 参考文献
[1]Khotanzad A，Elaragal H and Lu Tsun_Liang. Combination of Artificial Neural-Network Forecasters for Prediction of Natural Gas Consumption[J]. IEEE Transactions on Neural Networks，2000,11(2):464-473.
[2]赖红松，祝国瑞，董品杰.基于灰色预测和神经网络的人口预测[J].经济地理，2004，24（2）：197-201；
[3]汪璇，谢德体，吕家恪，武伟.集成GASA混合学习策略的BP神经网络优化研究[J].(2007)，03(12)；
[4]邓聚龙.灰预测与灰决策[M].武汉：华中科技大学出版社，2002；
[5]深圳市卫生和人口计划生育委员会[EB\OL]. http://www.szhpfpc.gov.cn/view?f ... 032=menunews&nt ；
[6]深圳市统计局[EB\OL].http://www.sztj.com/main/xxgk/tjsj/tjgb/gmjjhshfzgb/
[7]政务公开站点——卫生部政府信息公开专题[EB\OL].http://www.moh.gov.cn/sofpro/cms/previewjspfile/zwg
[8]林安弟.吐鲁番地区医院床位医生配比标准研究[D].；
[9]刘丽娜，我国医院卫生院床位配置情况及预测研究[D].山东大学.2007。

附录:
附表1  2011-2020年深圳市各指标值预测
单位老龄化（老年人口比例）（%）人均可支配收入增长速率（%）第一产业增速（%）第三产业增速（%）
2011 0.0178 0.1270 -21.6090 11.08
2012 0.0183 0.1150 -16.5183 10.62
2013 0.019 0.0912 -19.2546 10.96
2014 0.0198 0.1012 -15.9456 11.14
2015 0.0206 0.1037 -18.3001 11.99
2016 0.0214 0.1046 -22.9454 13.08
2017 0.0222 0.0829 -20.4666 11.65
2018 0.0231 0.0983 -20.0182 11.65
2019 0.0240 0.0887 -11.2366 10.16
2020 0.0249 0.0943 -3.0914 9.37

(1) GM(1,1) 灰色系统C语言源程序清单：
#include<stdio.h>
#include<math.h>
#define N 100
void main()
{
int t0,tn,t,n,i,m;
float e[N],q[N],z,z11,z12,z21,z22,c1,c2,a0,p,u,yy,y,s1,s2,g0,g;
float y1[N-1],h1[N],h0[N],h4[N],r[N-1],z1[N-1],a[N],a1[N];
float z2,v,s11,s12,s21,s22,ee,l1,l2,c3,o;

z=0;
z11=0;
z12=0;
z21=0;
z22=0;
a0=0;
p=0;
u=0;
printf("===========================GM（1，1）===========================\n");
printf("请输入起始年份：");
scanf("%d",&t0);
printf("请输入终止年份：");
scanf("%d",&tn);
n=tn-t0+1;
for(i=0;i<n;i++)
{
printf("请输入%d个数据：",i+1);
scanf("%f",&a);$ w9 O/ Q! j  d* B/ ?# z6 h4 U
}
3 Y: r! U. @# w# m m=1;) J6 A9 B3 e9 E' W( x4 c* k9 o
while(m>0)4 N6 a( l0 l/ x: H  L7 m
{ & C& v1 A* l( T& c( ?5 s# E% @
for(i=1;i<n;i++)7 I2 k3 O. X7 x6 q9 a
{- @& ~: ~; \8 z0 k0 [- ~* L, q
r[i-1]=a[i-1]/a;0 r  x5 R/ b- l! |: Y
}. U9 w# V! u- @0 S  y8 ]
for(i=0;i<n-1;i++). ^' I9 q# H( r
{0 G2 U! _  h1 m4 S3 W7 [1 Q
// printf("r[%d]:%f\n",i,r);
7 T: u: a/ Z7 p8 |0 `, d1 q }. X8 {3 f+ f# z! N6 _# a4 q
3 r" E/ {2 w& M& _2 |
m=0;. [, V" E. g+ ]+ n
v=-2/(float)(n+1);
8 X' f# D3 h* Y8 x6 Q l1=pow(2.7183,v);$ a, L' W  c. l; \  ~$ V" m: }
l2=pow(2.7183,-v);6 q) w0 ^8 i7 Z0 c* R! u0 q
) b& L$ a/ B+ d" N
for(i=0;i<n-1;i++)
0 F: E0 F8 _0 Q! V8 G" d$ l {
% M$ M- p+ T) s2 Q2 F if(r>l2||r<l1)2 b9 ~! l1 J* d. `# e, E5 \
{
1 ?2 Z) ^. l  \! q/ ]: Y printf("r[%d]:%f\n",i,r);
5 V4 t, V) n* l printf("11");
: @  i6 d: H) F3 [ m=1;
, g) T  P3 i, H/ X$ e' K8 @" g0 W0 J printf("需要调整，请输入调整值：");+ V. s! a1 A; W6 l3 K
scanf("%f",&c3);
( z* w/ {. T- Y, U9 R for(i=0;i<n;i++)
6 ~9 I# A% T3 t9 J: R {. j  E% a" P$ C7 ]7 l% x6 o
a=a+c3;
. S: d$ W& N' f }
" R; [7 |; R0 H" {! J, F0 _6 a/ O break;+ s4 X! E' r; |1 J
8 k/ C  c3 w% L, m- v
}) R2 D9 $ c$ h
}+ I. f& ?7 ?- ~9 v0 Q, e% c! n  D% j
}1 P/ Z2 ?. P8 U0 R) F2 D. n: P
a1[0]=a[0];" F, H6 Y% M+ i  S7 j) M
for(i=1;i<n;i++)- w$ |! v2 M3 }( v6 C" I' O9 [
{
" k7 V  j- H1 a0 r8 g) n a1=a1[i-1]+a;( O. x" m0 P+ ?  V' F4 `
// printf("a1 %f \n",a1); //累和
5 k+ J: R. }6 }7 X) b }
. _/ F* ?2 v: H, @
! D2 Y/ r  ^) y/ {- Z4 ~; o3 I for(i=1;i<n;i++)
* V3 |2 d. C1 d; k" {% m {2 i, r5 g3 B) _3 b$ X
y1[i-1]=a;
, D' `! @+ n7 Y+ f9 M }1 C1 O* N2 L! E6 ^  m
for(i=0;i<n-1;i++)' Y" U1 g9 \5 $ p- x- O5 r9 U' @: y5 s
{9 O- ?" |- _1 T/ q, K( P
// printf("y %f \n",y1);//缺原始数据第一个元素2 Y( W: E1 V3 R- Z7 C
}2 ^+ b* G1 w0 h& P" D  u
for(i=0;i<n-1;i++)4 _6 e  \: h+ V  F# P
{- B: b8 i! `6 y8 C1 g
z1=(a1+a1[i+1])*-1/2;
% P2 @; w/ D; x0 r0 h0 D }0 O; \3 h* N1 M% l' n0 d* E
for(i=0;i<n-1;i++)
" W! ]! b* P3 u( H4 o# w {+ B$ q( }% v# r0 ?) U
// printf("z:%f \n",z1);// 求1/2（相邻两数和）5 Z% A" r0 y* r6 M, G' j
}4 U- E7 r7 Q. D& z  b
for(i=0;i<n-1;i++)
/ f6 g6 M/ \8 E* K7 ]8 W {& B% j( @8 C' N4 r
z11+=z1*z1;
- L( e: v" Z( L z12+=z1;. {" n9 v- r. B) o" e+ j& H% W
}4 O# _' D4 z- `2 ~- J5 x
z22=n-1;  x, d- N: D8 R# l$ ]
z21=z12;
+ s7 A! ~' F& V8 H4 t7 ?2 z1 q// printf("z矩阵：\n");. ]  u& J& z7 |: ]! p5 L
// printf("%f %f\n",z11,z12);- G. V2 S3 c. O* u
// printf("%f %f",z21,z22);/ }* N' G9 i. q" o
z2=z11*z22-z12*z21;  Y  d" h5 z; m+ O; G+ K/ e
// printf("行列式：%f",z2);
; W2 z1 [3 n& c5 p/ v9 A s11=z22/z2;3 L# T% W7 c% M
s12=-z12/z2;
% {9 C/ R9 A7 v* y$ @. \, ^# e s22=z11/z2;
( C4 r) T2 w, ]9 V& ] s21=-z21/z2;, s; `3 ^( y$ y- z7 c
// printf("\n");
+ {9 U" f/ i$ I' s  X// printf("%f  %f\n",s11,s12);
/ x7 _" i' R. X2 [# `// printf("%f  %f",s21,s22);
9 O# I9 B% p/ q( B$ S5 f$ T c1=0;) L! B* E% G- i- @* |3 A+ [
c2=0;& o) Y, _  W5 s8 ~
for(i=0;i<n-1;i++)3 B6 q2 ]/ }, B+ o3 q! S# G
{
% `$ i: _0 }, z3 k9 H! {' h c2=c2+y1;
( Z( H0 y6 ~: ]2 ?$ G c1=c1+z1*y1;
8 e8 C  T' X6 [ }
- C/ Z: T+ p8 B& x) L// printf("c1:%f c2:%f",c1,c2);
/ r( p$ T0 i3 a( h% o. x( K& ?- _7 \4 }/ Z$ m
a0=s11*c1+s12*c2;
+ p0 h6 R/ Z/ X9 J u=s21*c1+s22*c2;7 c( c8 F5 M- x
// printf("a=%f u=%f\n",a0,u);
/ k, W8 _0 [* V) N for(i=0;i<n;i++); ~8 W; y+ F+ S8 M/ ]
{
3 d: c" c9 L& v0 \, F h1=(a[1]-u/a0)*exp(-a0*i)+u/a0;
3 f1 o( l% v5 T3 d# E* O }3 |% M$ U' v  ^% {$ u2 r
h1[0]=a[0];
  m" s8 Q! c  w/ B. _, A: e h0[0]=a[0];5 n% M! Z# w, D- x8 u$ H1 `* z
for(i=1;i<n;i++)$ |" W6 o* w9 G8 h0 H) P4 G' J
{1 }. H- Y& ?; E1 ~9 }" M
h0=h1-h1[i-1];1 S( F) c' m/ A) I4 x" Z
}( S1 m8 T& Y1 J6 r$ F7 s
for(i=0;i<n;i++)
; M3 l7 W% Y5 ]  M6 n% K+ N {
( N+ a) l9 `2 C+ C* B// printf("预测：%f\n",h0); //预测值！
% V, \5 W3 O& Q% o9 z8 z/ I* s }
- `* P# i' H' { for(i=0;i<n;i++)
. h+ O& d% w: G! q {$ r7 ?3 X% T0 S0 N5 V
e=a-h0;- l% v# P1 W: Q3 y
}0 P* I" F2 s& b$ Y
for(i=0;i<n;i++)
. z+ s8 v% E( j+ I7 a. b: @ {6 }9 t% s( U' y. ?1 G4 C
q=e/a;. ]; _" }3 A. D( J+ N# I
}
# L% @# T, t' I for(i=0;i<n;i++)
$ }# P2 e" k) }# ~2 s0 j {
' `# B" ^% v7 a8 f: s' x4 r// printf("e(%d)=%f\t\tq(%d)=%f\n",i,e,i,q); //--------e为残差！ q相对误差！、& J+ _; Y8 s/ `5 F( \; d/ L8 L+ u
}
8 `1 n, R, A8 S9 h* [# J5 e yy=0;( c" ]7 V6 n: U3 r4 J9 p* a! s( p% o
for(i=0;i<n;i++)" L7 B. ~- s% T4 h
{- a" J. z, J" J) D% h7 _
yy+=a;* O8 R5 l, X3 T4 v9 O1 v: s
}* K( V. z( ^/ ^! M/ L. G5 }$ |
yy=yy/n;4 ?  g0 [% j% x* j0 Q
y=0;' x. @6 ]" ]3 H) T6 i# t
for(i=0;i<n;i++)
, n3 E* i1 e8 N  o1 E+ G0 B6 u {
& i" {1 v+ k! x. L$ n' [7 p y+=e;
0 ?$ ]% y6 q7 r5 P+ K }
. ?! H, @1 ]$ x/ z0 U. o y=y/n;8 G3 [8 L& {* T9 a
// printf("平均数：y：%f e:%f\n",yy,y);//原始数据的平均数
) d. c5 J8 k: o! d6 z ee=0;
8 z9 z  V  P3 c+ ^9 f3 b+ |% d for(i=0;i<n;i++)
/ U% k( N, n7 b7 D5 F {
& [' Y3 T5 p( G. q ee+=(a-yy)*(a-yy);
4 U0 d+ W3 E) D& k }
/ e1 A, f0 L8 Q; X2 G s1=ee/(float)n;
* C0 B5 |4 \! ^: }- a- b& w// printf("%f ,%d\n",s1,n);
9 u( q# g2 _9 M  j2 q s1=sqrt(s1);6 o" s& |0 n2 ?( ]3 w1 `1 D8 q
// printf("s1:%f\n",s1);//---------------------s1
0 U- S4 M9 ^6 x ee=0;
0 m# I) A$ R- q! Q* k. [% y3 v4 G for(i=0;i<n;i++)" K2 ?( r& D( M
{7 p0 F! y8 w8 F+ |5 V; D
ee+=(e-y)*(e-y);
7 A) W5 _; x* i5 P6 ^$ i$ k }
  C" _" W% H! g. {/ I s2=ee/(float)n;
: ^- i. Q/ H9 l9 k4 c// printf("%f ,%d\n",s2,n);0 r! _' n  D- t9 c& j3 J- @2 e6 @
s2=sqrt(s2);
/ O, T% F  q, l4 G* w// printf("s2:%f\n",s2);//---------------------s2
) B3 h& }& |" C6 O& F ee=s2/s1;. [; H# x9 c# a. b( z6 x
// printf("均方差比值：%f",ee);//-------------ee均方差比值3 r' U7 f  `0 Y* t' x
o=0;
3 C$ W- C6 Z4 \: n) A for(i=0;i<n;i++)
. {" q+ V: O; F0 L% Y+ p {
1 Q) G6 y5 f# v if((y-0.6745*s1)<e<(y+0.6745*s1))
: F: s+ q  [2 f; h- j* e) x' { {& ^0 z+ m% C! N" z8 o
o++;& o6 X  I4 f( y' Y
}5 i3 D# w' o# }5 Z" Q1 v$ @
% x9 t- c( V' Y( k! `4 w; M) |
}. J) K( h" q, O* S" ?
o=o/(float)n;
7 F8 d% {8 Q' |8 E% I// printf("小误差概率为：%lf\n",o);//----------o 小误差概率
! ?6 h- Z. ~7 A- e. b printf("请输入预测终止年份：");1 b; U5 ]& P% A- N$ D, r9 L
scanf("%d",&t);5 H  F' g% v" w+ m. x3 b- j
t=t-tn;
4 I; I0 S% p+ _0 j& X g0=(a[1]-u/a0)*exp(-a0*n)+u/a0;' E+ q3 Y$ P3 i1 y8 p( A
h4[0]=g0-a1[n-1];
. h* C7 R3 n' k6 _ for(i=0;i<t-1;i++)
) C7 B% m, o) _( S$ G$ `; ?) U {
( s3 r. j" G7 p: [5 V' d! | g=(a[1]-u/a0)*exp(-a0*(n+i+1))+u/a0;! Q  Z2 i1 m! b+ U/ R( }" W  |
h4[i+1]=g-g0;
6 u2 x: J7 E  ` g0=g;
. K% r2 p1 b: A& f$ L+ y5 z7 r }//  预测0 P3 V& y; J/ m; ]/ w
printf("===============================结果==============================\n");
# ^. l7 u3 Q& n* w printf("序号：");# r9 U2 j# y8 V7 m
for(i=0;i<n+t;i++)
1 K8 M2 ?7 i, R- c, Q& E0 z {" Y. d( X8 p- D9 f, T
printf("%8d",i+1);  ^8 N' p/ W- C
}
3 H9 _2 W; J5 h1 j0 P2 C- ]- o" B  Y printf("\n");
5 |  H0 V) A7 o. w4 e6 ?* P printf("年份：");
, O# y5 @5 ]3 z for(i=0;i<n+t;i++)  L1 t# y+ }5 B0 `
{8 w: q" A2 _( a# J% @5 g: j7 k
printf("%8d",t0+i);
5 \& r5 _; G% { }5 W. R( b+ y0 Z
printf("\n");5 @/ a* b- p) U8 \" D0 w) _0 z$ l
printf("原始：");+ J3 A) r$ o7 ~  ]9 }
for(i=0;i<n;i++)7 m6 |! P$ m- P( H% k; I6 _7 \/ J4 d
{
. `( e# K2 T1 c% A0 z& u printf("%8.4f",a);3 x2 B9 H5 v% b3 a- Z3 k
}
+ r+ f8 t+ b' N6 u3 j; f7 Q1 _ printf("\n");" }: N2 m" o* L, @
printf("预测：");" v1 e+ a1 S. h6 q" E4 c
for(i=0;i<n;i++)! L6 W5 ~* F- B& V' G3 n. ~9 t# j/ v
{' W( j0 ~" _- T, T* X
printf("%8.4f",h0);
$ N# [& X- a1 E( n& K! h# F }1 x; O! M7 Q! T! M
for(i=0;i<t;i++)
, m5 x: d2 N% M5 Q# U! K" _ {
1 E7 p4 E, {0 R- v4 a  V  p: a printf("%8.4f",h4);6 e  j0 I, k9 S# L& k( d
}
0 \8 s5 K( Y, A  ] printf("\n");
6 @" _2 Z) i" K2 N printf("残差：");
8 w5 J7 w8 ~& I for(i=0;i<n;i++)7 v0 x- d! u2 c8 V
{% {$ P) _) J! X2 p* y% o
printf("%8.4f",e);
; ^; `: r: z0 k9 C }
0 l0 v" J, d! V) ]" M; d( }2 ~ printf("\n");# _4 S; U5 k! p$ y! c! _1 j+ X8 ^5 Z
printf("均方差比值：");
1 |+ T- {- W4 S* ?; E$ _; C, ^ printf("\t\t%f",ee);
) K# Y; ]* X8 a6 @# g6 ~! K printf("\n");8 n$ U/ U& J# `- q* Z/ f9 A
printf("小概率：");" M: q( b6 e. t0 B, _$ z  h" t) h
printf("\t\t%f",o);0 ^( I6 C$ y. m0 X7 A
printf("\n");/ v! o/ d( N# j% ]7 ^  Q
printf("==============================精度评价===========================");. R+ A  {3 h0 k- J6 B

/ Y6 `% d; G0 y/ ~ printf("\n");8 f. s1 N- l9 l( V. h1 d* }* _
if(ee<0.35&&o>0.95)
2 ?* O6 {' J7 j' t5 w" _4 X5 L printf("\t模型预测精度好！");
; {7 k3 k; g  k! }- ? else if(ee<0.5&&o>0.8)$ l' M- R6 [: I  D7 Q: e4 @
printf("\t模型预测精度一般！");
; O9 N6 n. L9 _8 x8 c1 ?: m7 Z else if(ee<0.65&&o>0.7)  o& h& \% v- _
printf("\t模型预测精度勉强合格！");
7 P& F  @9 q! j" L5 I% x! `! S else printf("\t模型预测精度不好");( V9 u, P# b8 G! e- @
printf("\n");# r+ t# u2 j0 a% Y5 A' |
printf("==============================预测结束===========================");& g; l# t$ y3 {2 _; M; W3 L# x. m
printf("\n");
, B) ^! q5 s9 I2 D printf("\n");( ]/ z- U, t6 ?% v& _+ h
printf("\n");- I  ^$ k. ^7 d: u% b+ P% Q
printf("\n");
9 z0 u7 l1 g% a& H. v- y7 |6 \" w9 K
' I. A+ G- t9 W! ?9 A& r
scanf("%f",&o);
8 B4 W" U% R* `$ W. k. n3 @6 j7 p! }) j5 ^
}/ T/ g) y8 z' h. R; U! q
(2)基于GASA混合学习策略的BP神经网络的C语言源程序清单：! [# f) Z+ u) `0 v; a
#include<stdio.h>1 B- P9 t! V$ A0 L
#include<stdlib.h>  u8 S6 r2 d' d- t
#include<math.h>0 `! W8 e+ y+ W6 D$ p3 h
#define M 10
) h5 A; B2 _  D. q. h: L7 q( ^#define N 16- x- z% u* z8 t  g) U- g6 j
#define m 10! Y* Q1 [4 A# ]4 g) {
#define jingdu 2000
" }; [; L* P% K% H4 p! [0 u#define jingdu1 1000
8 \# \8 w# w* z  g6 C; `) {#define jingdu2 0.1
; T" p+ V* R1 m$ J  C( o( Y0 }
0 G$ m, F- H$ p# y- E$ A% ~const double e=2.71828;
* U) w% L5 B: Y3 D4 I
) x4 l# c; o: v8 a$ Yfloat in[N];! w0 A3 G2 m' X3 i  m
float out[N];
. I) w! p( Z2 s) Z- Q+ n4 \* Nfloat get[m];
/ m& s) x6 G3 z
0 H* T+ v8 C; O4 \3 {
$ e9 k! v4 {- M) r) G: Mfloat one[8][M][N];# N5 K  k) g7 [* _
float two[8][N][m];) K. P! q6 q9 V4 |6 m
typedef struct
2 m  G' H! @  t. h{, B6 F2 y, S7 [6 Q3 `
float yi[M][N];6 I0 |' v; N# f9 y" H3 x
float er[N][m];
6 Y; C' K) V; Y6 n9 g float fi;' m8 `! C2 e! e0 q+ \
float Fi;
6 @1 _; c' e* M$ J' V}dui;2 s$ |0 Z) m4 F5 z8 a3 l* X5 w, ?% G2 k
dui du[64];8 \0 e# D8 A4 ?; E3 D4 p2 t2 r, `
dui du1[64];
7 t: }5 A0 }" ~' e; V. Udui du2;. n8 |+ T+ P6 P' S3 v
dui rao;8 O8 W1 ^+ p' [: e
dui gd;/ r' _$ o2 I* @- Y* K
( S, {3 O: i$ a4 a, `# C
float T=100;
% L% L! M" B, P  |" ~& [
- ?. M2 `! C6 `typedef struct
' `0 b' N2 A' m{
+ w1 J4 p  z  o# B! m1 n float year;
9 z1 V2 x- F& G  j2 P' G float num;; A, h% Z3 D. o0 U, `8 ]& a
}Data;9 P! e! S5 T% I/ ]9 W9 J
Data data[10];6 k4 a! M9 a) }6 M5 c

2 P0 }, t. ]; {1 F4 {
9 _; ]9 g* B1 V9 d( W# r* ovoid chushihua()2 y( E- r) i+ D4 m' c
{% h. w; R4 ^! y7 v3 c& I
for(int i=0;i<8;i++)
! k% ~5 ~8 k2 v9 a9 \9 R {$ L5 d8 s/ G' m7 ?2 w; m1 P
for(int j=0;j<M;j++)
: @5 s4 |' f: x' _ {
2 `" w0 H7 ?! B! @* R% c for(int k=0;k<N;k++): P( k% W% U) W5 E
{4 Q& ~- ^* i: d1 y) z, O
int h=rand()%700;# _$ l2 I/ I3 }" R# u! ?" T
int w=rand()%10000;
. {- B0 B. t; I6 M/ Y float q;
! Z; @9 H5 ~4 ] q=(float)h/10000;
, }* ]+ A  j* h/ b. |) r" u/ r q=q+(float)w/10000/10000;
; f9 H- k) D4 k1 k one[j][k]=0.0375-q;//
: o8 d. _) F2 R$ J- M h=0;
  v( [# a* {4 L- m  S }! P3 ?1 G/ G( H+ i9 n/ a, [
}' M3 u! M( {0 ?% \& F
}& R1 C* r, ?& Z# j% V

4 R) }5 E. i9 Y6 ]7 [ for(i=0;i<8;i++)( v% }' h% s- V7 i
{0 f1 o# D- f  m- O) n
for(int j=0;j<N;j++)# Q0 p9 x4 ~! k# m
{( ^; ^5 a) F0 j  l! R! k  Q# }( [6 s- ]
for(int k=0;k<m;k++)( ^) X' F0 M2 Y0 j
{3 V+ D0 `/ P/ Q7 K
int h=rand()%24;7 u, Z5 M7 U8 }/ S$ ^
int w=rand()%1000;
2 `& _5 E7 d2 W: X/ f+ E) y/ c float q;
1 b+ V6 Y3 A( T& |! U/ @. k5 n  p1 ` q=(float)h/1000+(float)w/1000/1000;+ j! \) Z8 s. C% w3 v8 f
two[j][k]=q;
+ |0 D1 @6 H0 S, O& z+ E) j, H h=0; //
& e3 W: \. G# j5 ` }+ G" e  }, w/ K# @% b! _# e! b1 _
}
% d8 t8 {  ]+ V8 G. m }3 o# R7 F( f1 Q% b5 x% q
for(i=0;i<64;i++)
( F* }3 e8 d0 ]( n { int h=i/8;
0 [" l$ D* D1 r1 X( s for(int j=0;j<M;j++)
5 e& o4 V+ `! e2 x {8 Z2 e1 W" l7 Q  i
for(int k=0;k<N;k++)
% M$ O- S/ u9 D7 v  K3 L) i7 _ {9 {% ?* b, U6 C& q1 t& t' f/ i
du.yi[j][k]=one[h][j][k];
( g! Z7 Z; b/ ~- M, Z4 s }( d- ]: {1 c  v3 N
}
1 [, Q1 \: q# p, m1 {! M2 ? int z=i%8;
" x8 m% j6 b9 n) p2 C4 E+ u for(j=0;j<N;j++)
& ?7 k4 ^$ o; ~* i {' t) ?! Z: N4 ?7 R& k
for(int k=0;k<m;k++)
- p/ B* N- j  o; a) |0 e5 b8 s$ g {
* d0 b" e' X) {8 v$ E du.er[j][k]=two[z][j][k];
' ~1 D/ G0 R  r5 F# V6 m/ E5 R% H }
- ?8 i6 s/ P% U6 t }2 @# s8 \7 A5 H0 a8 ?& ^: V3 a5 t
3 P; R2 g) W+ Q6 J* v3 ~
}: u3 H. D( K7 ~: p! Y! ?% Z

; H  u0 Y  C4 ~$ A/* for(i=0;i<10;i++)9 P) D) p4 A+ ^6 k' h- ~8 d
{
+ n! u, ?" T8 V- n6 Z4 ` data.year=i;! {& {9 W; ~) W
printf("请输入第%d个数据：",i+1);
; `) Y; Q' e" }  z6 b! Q" E scanf("%f",&data.num);
. ^7 `" b2 d  E* o }*/
& s2 S  D* h- P data[0].year=1;6 j7 R" i" \% l% U
data[0].num=0.1106;
7 \/ |- p' F) d data[1].year=2;  o2 U( N, k; {' X( m
data[1].num=0.1879;* E2 T! \2 Q5 i4 `; D1 g5 y
data[2].year=3;  C" C9 e8 p* T8 t% V. r. [2 Q
data[2].num=0.3153;9 Y' u& \9 U7 w" Q) B
data[3].year=4;8 `/ W* a, T( W7 [) U6 w( \  ?5 K
data[3].num=0.4591;; X' @* |1 O1 k8 Q4 J# D) G1 Z
data[4].year=5;
; W: U3 y1 F1 \& Z% K( j5 Y data[4].num=0.5274;) V; D+ W4 E; t; i4 w4 z; x
data[5].year=6;4 p* @  e- ~3 ^& }
data[5].num=0.5907;8 J& v/ C  P$ l3 l7 y6 y
data[6].year=7;
1 L6 O9 {+ }2 F6 y3 k' n8 J data[6].num=0.6748;9 t1 [/ g& t1 F% Y7 D
data[7].year=8;  d5 Z3 z" X8 E& ~3 L4 ^
data[7].num=0.7733;! T/ x8 n$ W- M/ |" C& V7 c* I$ |
data[8].year=9;$ I. e" J0 u. B$ m
data[8].num=0.8713;
data[9].year=10;8 T1 G8 v( K3 ~. V0 P3 G
data[9].num=1.0000;
% D2 x9 A. z+ A# {2 f2 a1 `5 M) x2 R  h- L! Z4 b
}
! q8 j$ Q) L* I4 [' |6 s8 r  ^2 [5 w" c' [

5 V2 z- W- _- _- C0 m2 ~4 T/ o5 I/ C- Z- B: I8 m0 c% T3 n

8 H; }2 v% a- W0 O8 R7 d1 s( @$ e' P' ^" ]% u
2 Q- U+ j3 C; A0 F. N
' J2 f7 h, E0 A. Q- l7 [( ^' s6 y
void yuce(dui h): }! M$ u& G+ a" E; N. C  x
{
- C0 y$ g8 `3 Z. ^6 A! l) M float z,g;
; f/ I: @3 E# ^2 v0 \: u for(int i=0;i<N;i++)
1 Q6 J5 h$ a1 k; @( `9 D- L { g=0;1 b4 ]6 Q2 i+ B* M- u7 `
for(int j=0;j<M;j++)
7 R# d5 `4 k' `2 k {1 G; i) e8 Z( K; Z7 Z, G, \
g=g+(j+1)*h.yi[j];& t' H; R( v  |/ N
}; J1 n: n' }( Z+ \" t9 @4 O( M
. c$ d! {) e5 [7 m) A' _. r* Z
in=g;
' k& u0 Y  a! m. }: C# s/ I }( X1 V3 G: N& f5 R

/ v9 N" P8 t1 j, Z8 Q6 W4 d for(i=0;i<N;i++)' z. d! ^" A1 c2 t4 X  b1 d
{; {. t0 P' w/ b/ B3 n
z=in;
$ ^' u) g, i- s' t' h3 m7 W z=pow(e,z);/ u- {' M5 B2 B/ k# |* A3 p
z=1/z;
% P/ Y# e% ]! P2 a) s  ~ z=1+z;
: x$ B, _- |; L2 G& O" ` z=1/z;
# I# c- z; N/ E  U6 }) a; f out=z;0 h8 @1 X( O& W! v: [
}
5 g: O" I$ V4 Y3 G& Y6 c
2 |: C) Q/ f& J; n% @ for(i=0;i<m;i++)
# V9 [! s2 K5 o. i" U/ L% @ { g=0;3 w* j  x) R! M7 t* S3 S  A, I, M
for(int j=0;j<N;j++)
- ?% _4 ~* W% b& o  L {
  F4 I- ?& e8 U1 l; P5 z  H g=g+out[j]*h.er[j];
2 |1 Q, }- S1 G! D# t8 w2 o, ^( n: f, ]
}
: g; c  c/ _) A0 E- w get=g*10;
" C# M: ~1 X3 Z7 s; n7 R9 H }  e. u2 `( W- D7 U3 U1 F
for(i=0;i<m;i++)
8 j0 Q- @$ S: Q {) `' R! P4 r* {$ }
printf("get:%f\n",get);
0 d2 ^# z9 h$ [1 d) S5 A! Z. i }
# v; P, O+ @/ D0 H( C: g- k scanf("%f",&z);
; J% h$ R# H3 O7 v) g' H}
& s; ]0 j+ b7 l" X2 ?float shiyingdu(dui h)0 s! n: E* B& k
{& c& j7 x* z8 g/ \* V3 Q  R
float Fi=0;6 K0 i4 v( m5 Q# G* `
float E=0;$ \  ~( @# i4 Q7 s) F- F. _: y
float z=0;3 P; Y. ^0 B+ q7 n
float g=0;
6 p/ a, \) E7 }* a' j( F7 K3 V' u float in[N];. V* k% Q* x( `- [. B, K. ]
float get[m];7 [. x$ |* b1 b) c; d: M6 Z
float out[N];* D/ i: o* M7 ]! g( C; P) o
for(int i=0;i<N;i++)
( o! _- i7 \5 {9 X3 L {% x4 o, y6 S* E! c% I; L
for(int j=0;j<M;j++)9 F& o# C2 H( m$ k
{' ^' ]6 ]0 h* ]/ {% N, M7 {
g=g+data[j].year*h.yi[j];
8 c8 [6 f1 J$ ~# ] }
, w0 g4 {: Y5 l' Z. k in=g;
( Y  g6 |  Y- ~+ q0 N! e% N: { 2 R" t4 T1 P) ~9 C9 d$ B
}2 T7 u8 [% M# H

  p9 `; Q. T" y9 O- w# ^- U. ]% m  w
for(i=0;i<N;i++)- j6 @; L- x! q8 X4 K9 }
{
% ~7 R, d) Q2 F z=in;
/ n, P3 u* i9 d0 }- J; p# `* e0 s% o z=pow(e,z);0 j6 u/ K7 d0 _8 K+ r
z=1/z;
( @5 Y5 O0 r9 |. D( `. W9 V1 p z=1+z;
3 J6 p: F1 j8 v" W. ], T7 {4 f1 F: B z=1/z;# [# s2 ]# f8 o. g/ H
out=z;
  N1 V5 a2 |3 Q: O' h* H% y% M }* @9 I' X+ l) X2 K2 X/ ^' A
2 c/ M$ h; a/ n+ ]
for(i=0;i<m;i++)1 `0 P8 b# ^6 t: U& G' A
{ g=0;6 g5 }! T  J4 C. t9 N+ j
for(int j=0;j<N;j++)
: m5 ?: g  D0 ^ { 4 Z' ~  C+ w% d# [$ e  d
g=g+out[j]*h.er[j];1 I" s  f" G) j6 z
}
: M# A3 B" s! E7 N  r get=g;
8 @' P8 H3 Y8 |" V0 _ }7 _$ \# V$ n  W* B- Q3 h

' D: p# p- i. }# v8 r( g5 w# M) e  t1 T& \# g' C% g' `: B/ o
E=0;
) d) C9 z' Y" i7 ~& z/ t for(i=0;i<m;i++)0 z# g5 T' v: [, H! d
{ # l6 X4 L3 \( c. Z  V2 s
E=E+(get-data.num)*(get-data.num)/2;- P5 t+ J' _4 d# L+ X! l# l6 o
}
" U6 \+ M+ D& d  L
. N) ^+ l' N% Q if(E<0.01)
3 D+ \0 w* J. U {, c: g& c! b" E5 B5 Z
yuce(h);( @' r" j& J( _9 {$ j
exit(0);
& `& d6 z7 p! g }4 b4 s+ U' R4 `# N  ?9 b0 ~, ?! }
return(E);# t3 B! J: H& O5 ^( H/ [( T  O
}% E6 D& |! D1 n- ]! j
- _9 |7 K; b+ _% z3 M, i
5 g$ f6 \2 I6 q2 X
void gailv()3 E/ E: f' G2 m5 W" b  F' w# v
{0 j& ]$ f) s; L0 D. L+ K
4 q2 @" l% i/ r% b
float l=0;
6 R* F# ^+ ^2 U* P7 g9 j float max=0;9 d2 K3 a! j4 p- t4 \/ I2 Z
float min=1000;. v  i1 o. U% A+ v
( Y  h+ M5 a4 V* |% \6 Q3 F8 `
for(int i=0;i<64;i++)0 f+ K" J" I3 @) J! f
{- ]. V. D9 S  Z9 ]7 Z- e! D$ j% S! p
if(du.Fi>max)
: E) i0 ~: C1 D3 b max=du.Fi;
& \9 u0 F- z8 o/ D }
0 l. O2 ^2 [$ U" y for(i=0;i<64;i++)
; l5 ]) U4 {" Q  m$ c  w5 d {
if(du.Fi<min) 7 i7 E/ A* U# v9 g8 E
min=du.Fi;
/ _* |; B7 _# n" P/ T& t/ i; c }6 F+ e$ ~% v  d' F8 q
for(i=0;i<64;i++)) C4 \: e; E* Z/ e
{$ [, w, I% u1 M' z( i: h0 T1 R
du.Fi=(du.Fi-min+0.000001)/(max-min);! x& l# j( `/ B: A3 ^. G
}% P. P. d8 c' G% F
0 Y5 \2 B9 V( g8 Z& H5 T2 N
for( i=0;i<64;i++)
4 W  |4 B0 C1 g {- z: B+ c& T2 E" |! S+ s

) r7 Z0 G3 R  \ l=l+du.Fi;. Z- f3 t) M1 B, K
}1 b0 M( I4 j" Y- {/ `# V
for(i=0;i<64;i++), |; i0 u; h6 M) I
{& l% K% t- P8 i1 `, r' B+ P3 g$ a
du.fi=du.Fi/l;
: _) y% F# z5 M5 y5 E4 t }/ L$ J; P6 E1 [7 O: F

}
4 ^! z/ u7 }& ?3 b
8 j) A5 J& U1 h5 H; K1 p
+ j7 q0 F; C& ?
+ u$ O+ j( O2 W+ C# `3 {! j( W6 A" F) }9 z, q
1 n/ b8 U- `" x0 N
6 C5 C- c& [. t# H/ E! V: ?

8 t5 e2 ?. j$ D8 g! Q* u+ c3 O2 o; z( |1 {9 N! O6 Q  k9 @

( Y( \& R1 g1 u6 X; a" m
5 P9 I" t9 z. h& n9 Nvoid lunpan()4 u% I/ }0 C) h  W
{int t=0;
! D: u1 b1 u" v' n6 p+ v. I: o: a5 F for(int k=0;k<64;k++)# A/ e; @% C: h# E: q# c# u$ V
{
. @( f8 h' Y  T- B) ?$ d float p=0;* u& N; l$ g) o" a4 K& C5 ]

& y/ k# s4 \) @6 t; x int h=rand()%1000;
: }0 n. a2 U# w# T. C+ r1 K; J int w=rand()%1000;" C; a2 L7 c/ f4 ~3 `2 N8 \2 u
float q;
3 p' F" p1 C+ Z6 q/ E q=(float)h/1000;
, b7 c* y. ~+ B  C  r2 K# \ q=q+(float)w/1000/1000;0 ?( m6 B! u+ n8 j4 S8 ?: @

9 V, G1 b9 T, \8 C, m6 |6 U4 b- x" J for(int i=0;i<64;i++)4 u; p; K$ G5 E1 G8 I
{
" \/ z" u7 ?9 Q" w1 V! S% _( [/ I p=p+du.fi;
/ _5 e( J3 n2 t; m! o& |" Z5 c if(q<p)
& _( I6 K% j! Z7 J) p( n# ~ {
; o" k! o& i/ [8 o4 g, x. M& B, J for(int w=0;w<M;w++)
$ H' S8 s' w7 ?3 J' V- ^ {: d9 u. c, Q1 l# u9 o& S; A
for(int r=0;r<N;r++)
# G4 J- V1 Y. }/ o {0 e, u. e% F* c) H2 \( {
du1[t].yi[w][r]=du[i-1].yi[w][r];
! y, c6 s! ~$ T, ^8 k  I8 w5 ^ }
4 v: f* @4 z7 j9 ]& }9 | }* B2 l9 @- ?3 o7 r- q1 ~+ }
for(w=0;w<N;w++)
. s- Z& }' t6 O! x# w4 m: Y# @ {
/ X0 G( r# W, t' _7 A for(int r=0;r<m;r++)8 A- C* Y# f3 I9 K/ ?
{+ w3 q( ]. O% C" B+ d
du1[t].er[w][r]=du[i-1].er[w][r];3 i2 Z8 g# |& j1 F9 e. a
}% ^! ^3 c4 z5 c  }! \  K; ?
}- T7 P0 J. Q" H4 z( \
t++;
3 l+ Z% e5 w+ l/ |5 b) I5 c! y0 J break;- D+ n& Q+ k0 ^5 p: ]
}4 t- f5 ]2 w3 q* H$ a- d0 w! v
}3 J; l/ V7 M! n; l
8 d5 P# z8 P/ K- c! D

6 n; M# [2 F; ^ }
- A7 O2 p0 c) I2 B}; [8 _3 f# b% z  v0 O! ^% W- s  _
% ?0 Z1 h: v$ k0 J! U7 {' x8 Y

6 f( A. k; q9 t6 {# f, P8 o( k7 ?2 x  `7 g2 e, R

4 H: x- t0 [" V+ }0 K! T4 a9 H+ D7 `2 d2 k) ^1 e
3 A, o. _( ?+ I( b6 U3 h3 A7 Z
( F+ e0 v# ~1 y( l: j+ q) c" W" e
void jiaocha()
1 S7 \9 n1 p( V" `) d5 r1 G7 D0 m{
# {" G0 ?1 K" R# J/ U6 `6 k for(int b=0;b<64;b++)
* c" i5 ]- r2 R# T' D {4 Z7 a& Q/ s) Y/ ^$ R
int p=0;
; u9 ?5 R9 S. z. J int q=0;$ t2 t- d- X& |- H, d
int o=0;1 a( E1 A4 s1 s; k9 a
' H  i8 {$ `( @
int s1,s4;% [9 e4 X) w4 d+ M6 I
float s2[M][N],s3[N][m],s5[M][N],s6[M][N];
2 C/ x# }- Q% ~ p=rand()%64;3 A& ^/ @4 I9 n- c
q=rand()%64;5 t2 S& m8 G: s6 w
o=rand()%10;5 h, n" |- o( ?. j5 F& D" g
o=(float)o/10;
0 J9 v% i2 k8 ~ if(o<0.2)
; G% V6 N; k2 [0 ~! v& L {
2 s9 o8 `. I; J, }0 H* ~/ O0 O# y+ D s1=rand()%10;- G' r" P: f9 W. P" O. y
s1=(float)s1/10;: p3 g/ O* a9 x
s4=rand()%10;1 x7 o! i9 M6 }, w
s4=(float)s4/10;
0 v2 p; l& q2 W& s, W" ?* l( [9 K% J; c) F, n% y
for(int w=0;w<M;w++)
6 V* _' z8 v& `. a# o3 g! g {
6 l! a. b* A3 Z for(int j=0;j<N;j++)' a$ d/ a8 i0 n; C& o) |! S. V, C
{) z: h/ Y2 ]) H
s2[w][j]=du1[p].yi[w][j]*s1+du1[q].yi[w][j]*(1-s1);; w* k' h. D6 [: z, Y
}
+ d% i  B) E/ j }% o; ?' n. i/ n( N8 L2 \! e7 V
for(int i=0;i<N;i++)
2 @/ v# r1 d4 I2 U {
5 w- o) C2 l# [+ a" v for(int j=0;j<m;j++)
, _4 @) L0 Y1 o1 E, ~ {+ p5 D# \( d3 m/ v& ?: M% W& b0 T$ A
s3[j]=du1[p].er[j]*s4+du1[q].er[j]*(1-s4);6 ?, j3 U$ D# c6 |5 _
}
8 w5 p$ N) S& A4 k }' K" p( Q# `, X" g

( I3 V5 |  A" } for(i=0;i<M;i++)+ N/ k  b5 J; d7 p- H
{
) X) t! C5 X+ O; l9 N* x; q9 e- m for(int j=0;j<N;j++)
* d# N( F7 r" @5 K: k {
/ T! y) Y- i" b2 v$ |  w9 L: o s5[j]=du1[p].yi[j]*(1-s1)+du1[q].yi[j]*s1;
/ Y( q# F4 S/ m3 ? }) s% t* g1 s' {7 O7 T$ ?
}
: S1 J6 `' {# E for(i=0;i<N;i++)
# A; ]1 n& ]$ ^# G/ R9 \. m" H {
" R( Q2 c- S! `; F! ]. L* j  Y; L. r for(int j=0;j<m;j++)
* w: {; F/ K+ F4 g  e {
0 G4 S( m, l2 c" ~( E( K s6[j]=du1[p].er[j]*(1-s4)+du1[q].er[j]*s4;
2 e8 B% w9 N7 j- V }
' `  ]: S9 b# [% R3 Z6 l }( F6 ~' f: q1 C, `1 F4 ]
0 g6 J. G! `  Y3 g' v' b$ J
% o0 @/ z  ~9 R! [+ [  u5 M+ y! R
: B- H8 G8 g: v, w
for(i=0;i<M;i++)
+ I4 r8 n9 T) m& r( k {
4 o$ ]& U( B4 p( V for(int j=0;j<N;j++)+ w' ^" g9 h8 F8 ^, O# N* c$ e: M
{% x$ P/ {" V/ V5 k1 E+ x
du1[p].yi[j]=s2[j];
6 ]  n* G2 `3 f5 Z% H' ^& h- R9 ] }0 P0 o6 M- {' N7 j
}  E6 ~6 x- A! h2 o
for(i=0;i<N;i++)
0 Z7 w5 E- d8 h3 m {
+ B/ v# o8 \, |8 D$ m: u for(int j=0;j<m;j++)
; Y- |' ^! P. K {
$ U0 U0 K; d: i" m du1[p].er[j]=s3[j];+ x5 d: |) X- A, m
}5 L  R: v0 v; a0 F6 x2 p2 G
}
( u+ Z- L+ g; H/ ~7 w
. L$ n1 s( z' Q- t" G2 O for(i=0;i<M;i++)
2 M9 e: U  F( k: G {+ S( ]% Y. |# M3 }6 u
for(int j=0;j<N;j++). c9 v% ?% c) ^: K* Z' L$ H
{
3 J) u7 |0 x0 C5 t du1[q].yi[j]=s5[j];
# |2 Y7 x& O6 ]% `1 j }
6 g- J2 b4 [5 z0 o& K1 S6 A( Z8 m }
  r* B9 e" o4 C2 T for(i=0;i<N;i++)
% F+ ?, E* S* `( Y# O+ q {
- ~/ U, X  E+ F- w$ X for(int j=0;j<m;j++)( u6 [( J2 M' W
{
: u: a% H& s/ w! X/ Q; S6 }6 k# o- F du1[q].er[j]=s6[j];% [  l1 m# h+ V+ p1 @' T
}
8 F+ c* d! E7 P# f1 ?" e: E }3 m5 l5 ]7 o' I% M0 R% k. z* U
}0 {8 |; w. M  B8 J* K' m, A
}1 M" v9 G0 |# l; z, N' V( X
}
# q: k0 C1 K- S& q$ U
# \* o8 R; ?- S& B0 y' E% }8 X7 u) A
1 E; ]: V8 y$ J, g/ ~void bianyi()
$ a4 u( _8 Z1 m+ v* ^* I{3 |9 j" J7 [$ `- p7 y1 V
int p,o;9 k4 J! G; A5 k5 w4 r
float r1[M][N],r2[N][m];' G' F( S; m( B) l8 Z
p=rand()%64;2 |8 t5 R3 r( e/ @9 p
o=rand()%10;
6 q3 L5 V& I3 I4 }2 o0 C. e o=(float)o/10;
" q' e  V! P& {6 s if(o<0.01)% }( d4 ]. g& F) L' V# A- S
{( v" G; C* \* {2 i8 w2 H; p( a
for(int i=0;i<M;i++)  U  I2 R' o7 G7 o
{
, c( D& N; H; @& w# ~% w. \# S7 ` for(int j=0;j<N;j++)
& b2 T; H/ i) S {0 |, `' D% T/ ?9 N# F/ E6 i: H- p
r1[j]=rand()%10/1000;. c* I( U# s' w6 g3 @
}
% i/ ~8 s* R$ k4 ` }
6 Q' F  g2 n. B) q' C5 A for(i=0;i<N;i++)8 ^) M0 l% i5 `2 W
{
4 }' z! O' ?6 [ for(int j=0;j<m;j++)' T# M/ l/ _4 o$ f/ Z
{
6 r$ O! [( W; r. L# ^$ l r2[j]=rand()%10/100;
5 k$ ^+ @% I! \5 s3 @) [( ]7 i8 k }
* S! i" `* a! T3 \0 J8 Y }& @1 z9 I1 X/ \4 J
+ l' Z: H0 }, E- I
for(i=0;i<M;i++)
% M( ?9 X3 p. b- D* i/ Z  r {
# O: {6 t+ }! i) f* h# M for(int j=0;j<N;j++)5 F2 a; h4 d& U4 x8 ]3 H3 O
{
; w  [! X/ a7 V+ z% e2 u du1[p].yi[j]=du1[p].yi[j]+r1[j];
) W3 S& J. [' U$ s }
8 S; U! L% \6 D" o: j }
$ l. C7 X& q  I1 Q; n, G' ^% Z5 D for(i=0;i<N;i++)
8 W, o8 P/ g- k# `7 b8 o  u3 H5 ~ {) x# `6 J0 L; K4 \
for(int j=0;j<m;j++)
. o  X2 E- \! Q; f2 I {4 Y( i: k" E' S4 _+ ]( i* b
du1[p].er[j]=du1[p].er[j]+r2[j];( Y5 M1 p/ \( X  x
}
% b5 t) v9 O8 \/ X0 M }
& l+ q# R" ^4 t5 }8 ^* u: A( q5 j. _. P& D* l
}) _* k* I' |/ G( G) ]
}
4 p) q$ _4 A4 \: q
. `1 j+ M/ `9 J; v2 `) ]$ ]& i! D! f2 Z3 Y- e) s! A

3 `, m8 O' ^& y4 O, B+ ~void change()* M( E' S; d% ^7 I. M& t
{
$ ?3 v" D, z2 V( i1 v for(int i=0;i<64;i++)8 n3 l9 u  h* x4 C+ n2 [! V
{/ w# T8 ]6 t6 E8 d) N6 p( [
for(int j=0;j<M;j++)
3 A: P( b- g7 z* q5 |$ D) { {
4 D+ N9 `7 G  `0 K6 W1 Q% \& {7 ]5 \ for(int k=0;k<N;k++)
7 ~* a- X& F. p  p! t/ O* y! | {/ t# F* t' d. F- f
du.yi[j][k]=du1.yi[j][k];6 R/ X0 q2 I( r8 n6 e
}+ I2 j! s3 ^4 A5 w
}
, @+ s( K$ _& ?1 x5 w+ m% m$ | for(j=0;j<N;j++)' o. l; Y+ r* M( h6 m$ L
{
9 M  ?0 r$ O* A) X; q+ n3 j! f for(int k=0;k<m;k++)1 u' ]* M: O# }7 G' l# z7 ^& x
{
- A, s0 d5 L/ [1 `! L- q du.er[j][k]=du1.er[j][k];$ B8 h8 |& U" P( m3 h+ W
}
2 Q; n: D+ N1 i3 ^ }) Q' m& ?0 r9 O" z. O, d, S* G
}
' g  u; O( ~( J, P$ e  X}
9 K8 F. S5 @. l- y! {# C* L6 @  s2 h% |# U* C+ x7 z
0 `5 Y+ Y/ v6 N4 e) ]" |8 }/ t
  Z6 ~* v& z$ ]% [3 b+ U1 s

' M( ~8 B* r/ ]1 Jvoid raodong()
( S" H4 h5 W$ z5 D{6 r- n" L# A: p3 ]3 {# `! @) v
for(int i=0;i<M;i++)6 [- a( W. ?7 k& t( p3 C7 m
{
* e* m5 W0 y( }+ ]* {7 w for(int j=0;j<N;j++)2 C+ Y$ Z4 @# h9 |) f/ H* v
{
% S# w" X% E- J rao.yi[j]=du2.yi[j]+(0.1-rand()%2000/10000)/10;% t4 G* L5 Z! y5 w
}
$ T6 q0 `2 X; d; E! q: G }5 c, G) d8 X2 P8 w; F" Q
for(i=0;i<N;i++)7 p& x1 l/ b' C; ]; G
{
, b0 C* F) `( b for(int j=0;j<m;j++)
5 [" ?9 Z& k3 {, A- y6 R) K. i4 K: W {/ h5 V# c4 u) y# H9 K
rao.er[j]=du2.er[j]+(20-rand()%20)/10/100;
  N' f0 h# q4 v& Z) ?4 z6 z. U }
% v* C% ^' d2 N# Z: e5 V! F }, \3 m9 [1 n, G9 |, x/ _4 U# I& j
}: \4 _$ m" l4 J

. t* b  C* d) G3 R% ?' d5 T
! Z7 r# c5 D0 j+ F- U* Q
( r6 T& d* G0 r5 l, M9 p
6 G- l9 t( @2 G  Z8 M* a) r; |& `
" i; z# C& a# p5 R/ y
9 x6 d8 y0 F4 m) t! Nint qushe(dui d,dui r,float T)) p: w! a1 U1 d$ w; u# u
{) v% R, b" w: o! B3 X, J* c
float w=0;
2 z( K9 H' q7 U  ^/ U float p=0;! n/ D8 U2 _8 X! z
float h=0;  V: p0 Y% L* W4 N" l* Y5 K4 Y
w=d.Fi-r.Fi;
4 H3 e2 X4 A4 x/ _4 Y3 X w=w/T;) o5 }% x# l6 ?8 W! [" K: w
p=pow(e,w);
, c) a1 d$ Z. q# }4 J h=rand()%1000/1000;
7 q4 Q6 n: Z9 w" Z: n if(p>h)
6 }+ `% V0 L3 N {, x! s% G( T7 i
return(1);
& @9 I: x) E4 H. d& T8 k. @ printf("\n概率：%f,%f\n",p,h);5 V& p2 i, O$ n1 c! C6 }
}
0 @. b) O. I' I  O else4 e9 x# Z, e5 o) A5 h
{
* S; |0 g: U! t; @ return(0);2 ^2 a1 b) t6 r" [$ X/ E3 k
}
% G- V# D! q0 w4 M1 ?- D- a( _}
/ e( K0 v# ^' H' p, x. B( o- g" Q/ O; u0 S; d: a+ e8 y

& v# v8 L8 V' }4 y" D. m& E7 n  {
3 [+ @+ u" b0 J7 {! E0 ^
8 x" g# D0 Y- G% R; N3 M" h& s, |+ I. i/ n
void yichuan()
% Q+ Z1 G& P3 p{
- c7 w' t7 o  r4 F6 j for(int i=0;i<64;i++)
, ]9 T+ h2 U- i2 K& q {
5 x4 r# {4 X' A2 h! f. } for(int j=0;j<M;j++). ]0 x6 D3 E2 A
{
/ ]. `3 [3 P: r% n. n# v% v+ k for(int k=0;k<N;k++)/ B* o' m( |# _+ H  j0 x9 e# W' Y/ d
{' B8 Z" l, y6 x  [9 s
gd.yi[j][k]=du.yi[j][k];, [8 Y  c* L' B5 w( e0 b; F, p
}9 J4 S7 g- a1 U' S8 _( X% x4 C1 [  ^
}2 K8 w! l4 Z% B

' H8 {! N$ m! Y2 Z4 Y. Q! `* G for(j=0;j<N;j++)/ [0 t+ x* r7 `) ^
{
% j% J( {' \: r1 z for(int k=0;k<m;k++)
0 s% K- t* k* Y& w/ N {
7 n2 T# J+ [6 f; u; N. E6 a' \ gd.er[j][k]=du.er[j][k];2 C( \0 O. B6 S- @, ]
}
) z9 K: e' ~2 H6 X }( u& _: q3 L6 w/ i1 E: K, T

4 b- t# t: f4 [! ]  j* F# s
% d8 Z4 N1 O8 q' M du.Fi=5-shiyingdu(gd);
5 J$ y- T$ s$ \3 p$ t
, i# J8 E7 y3 k" e$ `) P; _' K+ L }
, p) t7 B. ?( Z8 B! P$ B9 @0 ^7 t0 z- N! l: G, h7 {/ K
gailv();
' @* s6 [9 P2 ^ lunpan();( ~! h: i  V( [) D" v' w
jiaocha();) g, v: o$ ?) a0 t% z
bianyi();
4 H. [2 P, v' s  I( d$ {5 Y change();# v, T8 b" [- n% n9 @# }- r

  m! C( H6 {( a5 h5 S9 j for( i=0;i<64;i++)
' w) |& b; n) }: C {
  v- `6 b; J% E9 A, d  N: {/ Q for(int j=0;j<M;j++)8 w* ]. Y% z" F( q, ^+ F& x
{2 s$ Q1 j+ p1 Z! H
for(int k=0;k<N;k++)
3 }0 |& d) p9 o/ T9 d2 E4 d {
2 D: [, N0 g# L' v! O& P) @" M gd.yi[j][k]=du.yi[j][k];- v' ?1 b( \6 L* p+ q0 H1 k! E' U
}
3 |' u! E* f- z$ j6 u }
  n2 k& e5 o) `- ?% A9 k$ s  H" Q
( f+ g4 q; o: I  e0 B. R' ^9 P for(j=0;j<N;j++)% b5 l; e! g" Q! {
{% ]% P! r% U* L7 P
for(int k=0;k<m;k++)
3 ]6 k& q! ?5 j {
1 r" C* g: u3 N% f/ j' Z gd.er[j][k]=du.er[j][k];
5 f0 @4 {9 E& K' L }
$ C( C8 G# N: c2 S. V }$ ]! Q3 D* e( C

* Q0 W/ a. F( \1 M8 C" \
9 i  n# P# ~5 d  M- O9 K3 R+ a if(shiyingdu(gd)<0.01)
+ U  @, e, e' c. d9 h) X  U {% p1 @4 c9 t' n( f/ f6 f
for(int j=0;j<N;j++)* l$ f5 O& Z# ?3 M" _5 o; u
{+ @& ]  h9 F. h+ I8 ]+ H& H# |
for(int k=0;k<M;k++)* Y; ?2 l/ ~! f. [3 J) d
{2 m. @0 t* L2 {
printf("%f ",gd.yi[j][k]);( Y9 N/ W# H' C6 X# L7 `3 B& K
}
3 r+ b3 g6 V; c7 K' v; Q }6 N' A6 b1 m& J* @& q1 Y( E- G& Z# C
printf("\n");
$ Z" W8 }4 B5 N# q/ V- k for(j=0;j<M;j++)% h  {; l8 {- `) V4 ~8 d  b* D
{1 H% M" ~1 E* I) Y2 s6 J( x
for(int k=0;k<m;k++)
/ \$ x9 M9 R0 U0 B" J {
8 m6 ~7 u3 ^0 w# @ printf("%f ",gd.er[j][k]);
% `8 U6 l/ a6 v, Z7 u }
1 t3 R& U3 t4 Z3 W" `" Z }
8 H- o9 @8 e, X- l printf("\n");
1 @# ~5 q1 a, k exit(0);0 B: v: j0 N( J4 G# C; z
}
: R) N: N" G, {' Z7 ]* |: ^  i+ Z2 o5 H/ l2 _# m
}
+ m# H) e1 {* H$ ^. H" Y
2 L( i( y3 n2 u; u* g) a
! P# ]: I" p+ Q% V' n# v+ K}$ ]5 j9 q1 {) z8 T
% x0 ]  }9 z* `2 t6 B" y
void tuihuo()& }* b( J, K1 a+ Q% E4 Y. r
{
4 c, ~) n% N  K  g! c6 j for(int i=0;i<10;i++)
+ A! a- `- }: l2 k {
3 G$ _) Y2 Z" a# X0 c& ? int sj;  u9 _0 g& w! I1 N; x  R
sj=rand()%63;
, M) J9 P8 k! u5 @; P! x# e8 V* M" q4 [* [0 D6 a
for(int j=0;j<M;j++)
8 A3 p. A# q1 U( k/ Y6 t9 X {
' G7 S5 ?  c( D* N/ u; Q for(int k=0;k<N;k++)
! z* R8 p: ^8 J. |8 l {
# g, _2 T5 i% z/ [) P du2.yi[j][k]=du[sj].yi[j][k];1 C( y4 I% P1 C9 i% y3 [+ d
}+ [4 t& d) b& |$ w
}% ~) f, V2 ^; p: p: ?, ?4 k

/ p. Z0 b  u7 J/ e  g for(j=0;j<N;j++)
& e2 f/ o" k% m$ _ {
; ~+ g% S4 }/ ~! ~3 b  w: Z4 Y for(int k=0;k<m;k++)
( S: E1 q" {# D  ]0 g& k {
1 }( k% a. c& j0 U# U/ W du2.er[j][k]=du[sj].er[j][k];
' _$ j6 s5 N% d( F; P; s: e, r }
2 I! l7 @7 X2 i1 X9 G }
2 l9 v8 K. D* w float Ei,Ej;. a8 g8 f& T' ]2 L
Ei=shiyingdu(du2);3 ^# k4 `0 A) ~, C" J9 o- }0 j5 ~
raodong();+ c$ P# o6 h, S6 N( M- X
Ej=shiyingdu(du2);, |) L2 @0 A2 O* r0 S
while(Ei>Ej)+ Y) C5 p  m* k  \6 c, B. G/ a  P6 M% `
{. k7 r' I( U) D; T& ?! P
raodong();
# s9 ~% n/ P; O8 ~ Ej=shiyingdu(du2);
+ K; |, f& |; R+ ?$ V& U5 j6 d; ` }$ I7 i& }0 k* W* p
if(Ej<0.01)
: ], J+ V+ N. h+ Q6 c# ~8 I {8 ~; ]3 i: I) H2 V# x, @; r
yuce(du[sj]);7 x! x2 ^1 h% }6 i4 I& v8 P& o" l
exit(0);
- j9 ~+ d! r: N' L; R }
0 P+ ^# u2 P$ D+ d1 O0 t if(T<0.01)3 b; R7 D0 j. E0 C9 @' {
{
, ^6 o3 K  X! H! a" o& ^. c) h3 o yuce(du[sj]);
5 H4 u6 q4 F, b4 j( a exit(0);' C5 G0 P% N8 ]! J- F3 }
}
) m/ k6 o5 Y; G2 N5 y' n# h3 E- {7 J3 |: f$ M: v- o

+ d# q  V7 G) S+ N7 a% H if(qushe(du2,rao,T)==1)1 U* n8 T" s# j! Z; s3 b
{
. ^7 |3 ?1 @4 c1 |1 {% E for(int j=0;j<M;j++)
1 X0 n1 g2 Y( a; D( r1 I {
+ T3 ~  V3 [9 \ for(int k=0;k<N;k++)& Z& i" V0 D8 b7 ]' |
{; {* l( i: J8 W% i6 W$ k
du[sj].yi[j][k]=du2.yi[j][k];
3 O1 k9 K4 c* ~# Z: ?( \ }0 S: e; i% f- [5 g0 z
}
4 _0 t& w0 j3 H. x5 B% _
- x8 N; \4 O: Z for(j=0;j<N;j++)& \+ W; h; ?: A/ A
{
! N% d& g' {0 m% _+ v: R for(int k=0;k<m;k++)
- ]+ I7 o" P4 k+ O, ?1 p  E {3 ]$ K  P. h4 k
du[sj].er[j][k]=du2.er[j][k];/ ?- H; |8 c3 c
}
$ |5 i8 ^. s( p. _# ~ }; g- P- J- K, R. |$ @7 x& A
}
0 k5 o/ b" l1 _5 R/ ?, d' n( d1 q5 J* ]+ h# D5 r' e
7 B3 o  s7 U2 W$ Q
}  E* V9 ?7 ^- ^- L3 C; _9 F
4 a1 y" K( U  w  d% B
+ K! F9 s5 k4 c5 ?' v+ H
}) n0 C. Y" U# w9 F% U" V
0 I0 \5 m5 K+ N7 |" x
6 n& u3 f8 N6 p! _- E

( I7 e2 U& r0 k$ ^# F# O3 M6 L$ H0 D4 U! d9 b
7 k- e" J9 D2 S

. S3 z; A7 S% z+ |void main()% ^; u, g9 A8 A+ e# M2 N
{ / u4 v( o+ F% ~! L3 P5 D
chushihua();
& A2 U' s$ {* f int n=1;) Y& S" o* ~; E, b: T
int jishu=0;
$ u* u' j: A8 A2 K" R; [3 i for(int i=0;i<2000;i++)9 d% r, s1 X8 Q
{
9 d1 U9 m& F4 A* z- e0 ?$ E5 n- }: W, e4 w& t3 e

: k! n7 ^% @' C5 I* `- ~ yichuan();4 @% v6 N4 {0 ?/ ^5 e. k
tuihuo();
# m% r, s1 _8 w
, w) X6 K0 X3 E1 g4 H9 F float p=0;
  O  j* h9 F' |) V7 l p=log(n)/log(e);' B# `7 a' r- b7 u
n++;) o, ?, l* U5 L$ I
p=1+p;
8 {! Y' o7 M- ^/ ?, d5 s T=100/p;$ K1 M1 N" p, }. T  D
printf(" 次数:%d,温度：%f\n",jishu++,T);  N; D! G2 }" \5 R5 S
}6 |6 O# _, z. A; e" `/ H
yuce(du[0]);
  Y! d+ g' O. U" ?1 a printf("\n\n");
# X: ~- i3 a7 s3 q printf("\n");
+ q# Q* x2 g/ y- _+ c exit(0);/ [. I1 {1 f* @% W$ ^: E

$ D. a6 A3 Q+ u5 q( r! i}& Q( f  [: h1 U! T( q
(3)人口动力发展方程C语言源程序清单：& N+ ]8 K6 Z) H6 x
#include <stdio.h>
# O" U5 K3 n8 ^6 r+ a% `/ m, C#include <stdlib.h>
$ o: }/ {) c3 n6 k3 {6 s3 _5 ]#include <string.h>& m8 c# F0 j4 V  @; p$ c
#include <ctype.h>, ?# C+ [/ w1 o# k5 ?1 L9 V

: D( Y4 W. {3 Y* \) u" P+ R8 o#define N 100//年龄分段
. `7 y+ U7 k. z: |( P' ^#define M 10//未来几年
, {; e* E( p2 |* `0 u5 R; [- D+ e5 Kvoid main()$ \  o8 R9 X6 |
{ ) y4 \( }: l* X7 J+ `8 x- M
FILE *fp = fopen("实验结果.txt","w");
# s( g; r2 T1 y9 k# T
! k, ]2 Q  J6 P' K9 U$ c2 f' s float num[11][N],out[N],in[N],Nin[N],Nout[N],ch[M][N],gd[N+1],m,t[M-1];
5 C6 P4 b( [5 @, ]; Y float c1[M][35],c2[35],c3,c4[N],h[9];
. t. s5 {4 x+ ^, k/ s+ R/ S float he;
+ {4 I" Q2 K5 P3 x/ V5 V int t0,tn,jh;& @: }3 R% I( C+ J. h
int i;1 }: U* H. M( n5 m" b+ }
1 O$ [- O9 x" o7 @% ]" M% }+ j
t0=1;
  r/ I. S; B7 V1 e( v6 ^8 E& h& o tn=10;
( {- Y& ?* p( s$ l& _: q ! H1 r+ C, U, i" w& z! E  P8 R
for(i=0;i<N;i++)
+ M6 B* U, t( a5 E$ w4 N {3 i% l- P4 j- W
printf("请输入第%d年%d岁的人口:",t0,i);
* ?, z7 G& ~+ x6 Q; x scanf("%f",&num[0]);; T3 ^) Q: r  P+ C1 v5 X4 T
//printf("%f",num[0]);
! C, |5 P0 c: ^; ^& O4 t5 h }. n4 s" N7 ?8 }

( l6 s: k# ?+ F1 b
; z( u# v: ~- ]: J  B  T* n) S+ j6 J' a: s# q
for(i=0;i<N;i++)
3 J4 R- Q4 ~& G( y {$ m8 B/ d$ X+ u3 ]8 _7 l! `
out=0;
+ ?* O! ?, r6 @# [7 P1 a( b; j( W in=0;  S8 v6 F9 p2 q( \2 R
}. K; n7 ^0 P  g- G4 S- j# C& r
, d3 u7 K5 u3 F  ~- Z+ H6 a( B2 m0 i
for(i=0;i<30;i++)8 Y7 x- m: p0 m. f( o6 g7 J
{
4 S7 ~6 S5 d( S6 s printf("请输入%d岁迁入比例：",i+20);1 d! {* o. _* @- {) z" h
scanf("%f",&out[i+20]);
' o9 z6 g2 P  F5 p' U // printf("%f",out);
5 g" z7 P" u0 X! X& \/ }" L* z }
& K0 y: K7 C! C9 ~7 Q" U. C
$ H# M. d& D! n# I3 V( g2 r5 y for(i=0;i<30;i++)8 _0 @- V0 ]- i" B5 P
{1 {2 [( d/ X* K6 p$ J3 j
printf("请输入%d岁迁出比例：",i+20);
* x& O; c7 U4 ] scanf("%f",&in[i+20]);2 K. o: x9 f2 E! O
// printf("%f",in);! n9 u; K- |5 l* c6 \5 r7 G
}5 J5 d2 ?1 S9 u: u  X" u- m

) \& L. O% {: T! Z for(i=0;i<M;i++), X* b4 z. d6 t( J- V
{# W# V* i* i  z. i& u8 I1 J
printf("请输入%d年迁入人数：",t0+i);
% E4 S" J( p) m7 l4 S scanf("%f",&Nin);+ I/ f- M0 g, J" z- Y
// printf("%f",Nin);
' p& H: f0 R3 l3 q2 S }% j9 W2 s; M7 j( ?7 M4 k$ U) T
for(i=0;i<M;i++)% j" p  ~- a$ J; J& I" c9 v3 z4 {  z
{
# l1 y) i5 `6 z. @$ V+ | printf("请输入%d年迁出人数：",t0+i);
1 G3 |4 x$ c! z" X/ B# ] scanf("%f",&Nout);
7 f4 r/ k! v" r/ B# N# r# u7 }9 ^ // printf("%f",Nout);
( T! F/ U( c1 k7 I. ^ }
, t7 N3 {- V& r  y! a9 i7 S1 N) l3 L6 f4 `! M0 h: `* D1 N$ u0 A
for(i=0;i<M;i++)
: h! n, e3 P: b. q' d- E" \% b {- M- C. ~; T* ^. w- N
for(int j=0;j<N;j++): h* @% ?- e) }2 _# A9 M, [
{  t1 G* ?8 o+ W, R0 x: `
printf("请输入%d年%d岁死亡率：",t0+i,j);
9 R9 B9 C: @/ _' |) k" q scanf("%f",&ch[j]);
" [) R! Z; n+ P/ x // printf("%f",t0+i,j+1,ch[j]);' K; K& ^8 p' {, V. a; {
}
% ^" b  r. a) z2 v/ y }: H8 N& }! g  \7 W+ U7 k
' F) ^6 I3 Y# A7 j- v

  p; o* {9 G  A) Y1 U% h for(i=0;i<10;i++)3 ~6 R& T+ |9 N1 C+ W
{ for(int j=0;j<35;j++)1 w4 Q1 |, d2 u  b
{
( \. y" o( `+ z6 N printf("请输入第%d年%d岁妇女比：",i+1,j+15);5 Y, Y4 H4 l1 m! x' v
scanf("%f",&c1[j]);, q6 I' ?7 c- F' J. T1 O8 o( G
}+ O* z% {. G! }7 Z  L2 H

, c% p% k/ b3 \4 R1 j) f" I }$ u/ C- R* `6 I$ I% C0 _
/ [/ \3 y7 U' I0 ^" J

9 Z  H" h/ x2 c/ G4 U for(i=0;i<35;i++)
  S" v+ N, h7 z, K9 ` {4 W' C1 t" \/ j$ \
printf("请输入生育模式率");
, h' ~1 v# x( ?/ { scanf("%f",&c2);+ C: L) O. `; l& e4 i( Y7 r" \
}
. u4 l. P. i4 ]2 b9 s
! Q8 l' x" {0 p3 X2 H$ n- ]  p. }! k
- m6 o9 h# d! v$ E
printf("请输入总和生育率：");  Q: b7 Y; E+ ^$ G0 H" A
scanf("%f",&c3);
; u( B% |3 H# P* j3 p& U: N: w
1 |1 e: z" ~2 h$ H2 n+ v2 h; u! \, w7 x
9 Z. G: n( A2 R$ E. H
for(i=0;i<10;i++)
0 d/ s& N0 J% v% W7 f( J {
  J* c7 m& @7 h/ b6 ~( v+ B printf("请输入新生婴儿存活率：");8 h. U7 _4 g; A$ E
scanf("%f",&c4);+ @9 y8 e4 c% V; h8 k" Q" [- s% d
}
- T! w/ f  ^" k
2 `9 I; {' L: Z he=0;5 E3 M6 X+ q) @1 y8 n
for(i=0;i<10;i++)' J- d) @" @5 z( ]; X
{
. J- h" U$ P& d+ V( C% H for(int j=15;j<51;j++), I5 S, h) o. a+ n
{7 h' Y4 ]8 d6 G5 _
he=he+num[j]*c1[j-15]*c2[j-15];" j7 |; H, N0 a+ c$ [7 T
}0 U% J+ R5 B: r- S3 n# t0 t4 J

. D. I4 ~! ]( U7 v6 |0 H" Y h=he*c3*c4;9 b' k1 t6 R0 \" j/ _4 L/ S

% x+ N1 R, o4 r7 Z }0 ?, d5 o& e) h8 ^) P2 v5 y7 ~

$ y$ F5 ]( i' E% i% S for(i=0;i<M;i++)! g) n$ v" z( p* m! B
{9 B2 d) g. D7 b, W
for(int j=0;j<N;j++), U; u( p+ `  Q9 D+ U  _
{; z" r  }6 R% U0 C2 s
m=in[j]*Nin-out[j]*Nout;
7 |# c. |; Z  {! ?3 w gd[j+1]=num[j]*(1-ch[j])+m;  U$ Z1 b3 N& S# o! [

- K6 v3 k7 m1 o( \9 h' A0 \. E2 }  z }
" x3 I; ~- x9 z3 ] gd[0]=h;
: B! H4 N( f) e+ x; o& `! I8 z+ j' a2 w) @. @6 }+ l

& a( @  @  L8 X* A for(j=0;j<N;j++)% [" H. ~4 j  D8 W3 n! `
{3 G! E" E) I% X* W& F4 R
num[i+1][j]=gd[j];
" ~: j( x1 d% v  I; H }
, E; ^8 W2 g9 E }9 M& n  X$ S1 c- O. R0 q8 S
# L# t& f1 W% e. C7 A9 N& S* q' z
printf("\n");
8 C5 d3 M) ?* E9 ^$ v" K6 v4 z7 k for(i=0;i<M+1;i++)( o; I4 S8 [6 a0 `
{6 `7 ~- p8 b5 D0 R5 \5 B
for(int j=0;j<N;j++)
2 s- k# x+ E+ ?% u9 {2 ^ {
/ W/ d! D  }) k! y! j  X' X printf("%f ",num[j]);
2 ^" b$ k9 t3 X2 M8 k' G fprintf(fp,"%f  ",num[j]);3 F- Z  s  V! n7 L( |6 s' _! }
}
' f# A! N5 b! W! ^ printf("\n");$ f& ~7 F) N" u" S6 M6 K' i9 V, W
fprintf(fp,"\n");
3 i* {4 h& P* u- ~0 T/ L fprintf(fp,"\n");' b( c8 D/ `3 ?0 Q& o, o
fprintf(fp,"\n");$ G9 P1 Y9 j" l2 u+ G
}5 D. n  r1 B4 x/ S

: y/ ~: X- f6 ?9 l6 E scanf("%f",&num[0][0]);" j3 i* _+ \- T7 r) O) ~
9 u: r3 f- z& u+ Q" Q2 f
}
# u7 m% v4 Z+ C3 v9 Y% O8 k0 ?* @* M$ m