算法

你好，在ArcGIS中生成泰森多边形比较简单。首先你得有一个点图层，例如城市点。其次你的点图层文件中得有字段，比如城市人口。最后实现：【ArcToolbox】窗口——【分析工具】——【邻域分析】——双击【创建泰森多边形】，打开【创建泰森多边形】对话框，里面的参数设置都很简单，一看就懂。最后输出的图形就是泰森多边形。

高低点法的公式解析高低点法是利用代数式y=a+bx，选用一定历史资料中的最高业务量与最低业务量的总成本（或总费用）之差△y，与两者业务量之差△x进行对比，求出b，然后再求出a的方法。设以y代表一定期间某项半变动成本总额，x代表业务量，a代表半变动成本中的固定部分，b代表半变动成本中依一定比率随业务量变动的部分（单位变动成本）。则：y=a+bx最高业务量与最低业务量之间的半变动成本差额，只能与变动成本有关，因而单位变动成本可按如下公式计算：b=△y/△x，即单位变动成本=（最高业务量成本—最低业务量成本）/（最高业务量－最低业务量）=高低点成本之差/高低点业务量之差知道了b，可根据公式y=a+bx用最高业务量或最低业务量有关数据代入，求解a。a=最高(低)产量成本－b×最高(低)产量用高低点法分解半变动成本简便易算，只要有两个不同时期的业务量和成本，就可求解，使用较为广泛。但这种方法只根据最高、最低两点资料，而不考虑两点之间业务量和成本的变化，计算结果往往不够精确

高血压会无形中造成患者心、脑、肾等器官损伤，引发脑卒中或心肌梗死，甚至死亡，号称 健康 的“无形杀手”。有数据显示，我国成人高血压患病人数达2.45亿，居国内疾病发生首位，并出现年轻化的趋势。作为高血压病的有效防治手段，监控和预防逐渐被重视。 根据《2018 年中国高血压防治指南修订版》，目前检测血压的方法有诊室血压，家庭血压和动态血压。其中，动态血压被认为最能精确反映个体24小时血压特点的方法。近年来，动态血压计市场出现了欧姆龙、九安、鱼跃等知名品牌，但它们一般都采用听诊法和示波法，都需要佩戴充气式袖带对动脉血管施加压力获得血压值，无法避免不适感且无法真正实现长期连续监测。 脉感 科技 则采用了一种新的方法—— 采用微型脉搏波感知技术，基于单脉搏波技术 原理，并结合血流动力学医学原理，实现血压、心率等的无创持续（24h）测量 。 据悉，脉搏波是人体重要体症信号，利用脉搏波可以连续反映人体心率、血氧、血压等血流动力学参数的规律性改变趋势，评估心血管性能，且先于临床表现，具有重要临床意义。早在上个世纪80年代，一些高校和研究型医院就开始通过监测人体脉搏波来采集心律、血管弹性等数据。彼时，脉搏波监测还需借助体积庞大的机械设备（必须基于压力变动），其应用一度被局限在实验室中。 经过4年多研发，脉感 科技 推出Mystrace腕式血压仪，实现了脉搏波监测的“小型化”。据公司联合创始人金文军介绍，该血压仪 采用了压力采集法（仅分析脉搏波，无须借助ECG） ，核心技术在于Realcisionu2122高保真脉搏波传感器（已获得4项国内专利）和单脉搏波血流动力学算法，可现多路生理信号的监测， 包括血压（高压、低压）、平均动脉压、心率、ECG心电图、外周阻力、血液黏度、心输出量等8项指标 。 脉迹产品图（来自官网） 关于检测精度，金文军透露，和医院水银汞柱血压计的临床对比试验结果显示：低压几乎完全相同、高压相差大概差2-5毫米汞柱，均在有效范围内；另外，其脉图与ICU所使用的CNAP仪器（Continuous Non-invasive Arterial Pressure，脉搏连续无创血压监测系统）的波形对比也是一致的 ，能支持医用 。据了解，CNAP已在欧美大医院普及5年以上，经过了大量的临床验证，证明它与有创对比数据准确。 对于商业模式的考虑，金文军表示，脉迹会同时面向B端客户（医院）和C端客户（普通消费者）；此外，还将与医院的精准用药研究平台和药企合作，提升高血压患者用药的准确性；并与保险公司合作，针对医疗疾病险的用户、降低心血管重疾的发病率；为养老社区人员提供监护等。 据悉，为实现服务闭环，后台会有心内科专家进行主动式监控，发现异常情况电话或短信通知患者或家属，提醒患者科学测量血压和按时服药，并提供相应的 健康 咨询服务，接下来还会和其他机构合作增加在线问诊和急救服务。目前公司已签约近25个退休心内科和心外科医生。 截至目前，搭载最新一代realcision的Mystrace脉迹腕式脉搏波速血压仪初代产品已完成小批量试生产，进入CE和CFDA认证和医疗注册阶段，预计能在今年八九月份上市；消费级脉迹Mystrace手环已在京东发售，零售价格1299元；同时与瑞典斯德哥尔摩卫生厅、上海胸科医院等机构展开相关科研合作。 Mystrace脉迹腕式脉搏波速血压仪（官网） 金文军透露，团队接下来还会针对其它心血管指标数据采集和分析研发新的算法，并添加更多传感器，不断丰富Mystrace脉迹的功能；未来也会尝试将其应用在中医领域。 目前市面上同样采用脉搏波监测血压、心率等基础指标数据的公司还有不少，譬如惊帆 科技 、皓脉、CNOGA等。其中，惊帆 科技 和CNOGA并不直接开发脉搏波监测的产品，仅输出底层脉搏波传感器采集硬件和脉搏波数据的云端分析，通过和其他厂商合作实现产品的落地；皓脉则有落地的腕式血压计，目前尚未发售。 金文军指出，目前市面上多数玩家均利用光电容积脉搏波描记法（PhotoPlethysmoGraphy, PPG）结合电极传感器来监测血压和心率等指标。而PPG的核心原理是血液折射的光谱分析，它通过检测特定时间手腕处流通的血液量获取血压信息，不包含机理（血液从心脏出发回到心脏）也易损失数据，准确度受限，难以在院内使用。 团队方面，目前全职不足20人（销售外包），创始人&技术总监路红生有30余年的自动化和数字通讯领域的软硬件开发经验，此前曾是爱立信资深软件开发师，曾参与主持过诸多爱立信交换机系统等产品及短距离无线通讯技术的开发工作；联合创始人&CEO翁整研究员曾任职于瑞典斯德哥尔摩大学环境材料系（核磁/波普），并先后在上海电器研究所、瑞典SCANIA、瑞典爱立信、美国TRIMBLE瑞典公司任职，14岁起师从外祖父——中医名医严二陵，熟知中医理论；联合创始人&算法工程师路扬毕业于瑞典皇家工学院金融数学专业，擅长各种数学建模。

你好，凯撒算法的原理很简单，就是对字母进行移位，比如最常用的右移3位。比如字符"a"变成"d",字母"Z"变成"C"。以下是一个凯撒算法加解密的示例程序，楼主可以参考：// Copyright @ quark// Date: 2010-10-23using System;namespace BaiduTest{ public class KaiSa { public static string Encrypt(string text) { string encrptString = string.Empty; foreach (char c in text) { if (char.IsLetter(c)) { char newChar = (char)(c + 3); if (!char.IsLetter(newChar)) { newChar -= (char)26; } encrptString += newChar; } else { encrptString+=c; } } return encrptString; } public static string Decrypt(string text) { string decrptString = string.Empty; foreach (char c in text) { if (char.IsLetter(c)) { char newChar = (char)(c - 3); if (!char.IsLetter(newChar)) { newChar += (char)26; } decrptString += newChar; } else { decrptString += c; } } return decrptString; } } class Program { public static void Main(string[] args) { string testString = "xyz XYZ ABC abc Hello, World!"; Console.WriteLine("原文：{0}", testString); string encryptStr = KaiSa.Encrypt(testString); Console.WriteLine("秘文：{0}", encryptStr); string decryptStr = KaiSa.Decrypt(encryptStr); Console.WriteLine("明文：{0}", decryptStr); Console.ReadKey(); } }}

凯撒密码是一种非常古老的加密方法，相传当年凯撒大地行军打仗时为了保证自己的命令不被敌军知道，就使用这种特殊的方法进行通信，以确保信息传递的安全。他的原理很简单，说到底就是字母于字母之间的替换。下面让我们看一个简单的例子：“baidu”用凯撒密码法加密后字符串变为“edlgx”，它的原理是什么呢？把“baidu”中的每一个字母按字母表顺序向后移3位，所得的结果就是刚才我们所看到的密文。#include <stdio.h>main(){ char M[100]; char C[100]; int K=3,i; printf("请输入明文M(注意不要输入空白串) "); gets(M); for(i=0;M[i]!="";i++) C[i]=(M[i]-"a"+K)%26+"a"; C[i]=""; printf("结果是: %s ",C);}

#include <iostream>#include <string.h>using namespace std;char plain[] = "pekinguniversity";int k1 = 3;int k2 = 5;int main(){ for (int i=0;i<strlen(plain);i++) { plain[i] = plain[i] - "a"+1; } for (int i=0;i<strlen(plain);i++) { plain[i] = plain[i] * k1 + k2; while (plain[i] > 26) plain[i] = plain[i] - 26; plain[i] = plain[i] - 1 + "a"; } for (int i=0;i<strlen(plain);i++) { cout << plain[i]; } cout << endl; return 0;}

网御星云v6000-a3320使用哪些密码算法分御Power V6000-U/A...UEE统一加密引擎、UCE统一控制引擎、UDE统一检测...通过流引擎和多核CPU调度算...

你讲的是实现时的语言注释，还是他的实现过程

// 哈夫曼编码(算法)#include x0dx0a#include x0dx0a#include typedef char *HuffmanCode; //动态分配数组，存储哈夫曼编码typedef structx0dx0a{x0dx0a unsigned int weight; //用来存放各个结点的权值x0dx0a unsigned int parent,LChild,RChild; //指向双亲、孩子结点的指针x0dx0a} HTNode, *HuffmanTree; //动态分配数组，存储哈夫曼树//选择两个parent为0，且weight最小的结点s1和s2x0dx0avoid Select(HuffmanTree *ht,int n,int *s1,int *s2)x0dx0a{x0dx0a int i,min;x0dx0a for(i=1; i<=n; i++)x0dx0a {x0dx0a if((*ht)[i].parent==0)x0dx0a {x0dx0a min=i;x0dx0a break;x0dx0a }x0dx0a }x0dx0a for(i=1; i<=n; i++)x0dx0a {x0dx0a if((*ht)[i].parent==0)x0dx0a {x0dx0a if((*ht)[i].weight<(*ht)[min].weight)x0dx0a min=i;x0dx0a }x0dx0a }x0dx0a *s1=min;x0dx0a for(i=1; i<=n; i++)x0dx0a {x0dx0a if((*ht)[i].parent==0 && i!=(*s1))x0dx0a {x0dx0a min=i;x0dx0a break;x0dx0a }x0dx0a }x0dx0a for(i=1; i<=n; i++)x0dx0a {x0dx0a if((*ht)[i].parent==0 && i!=(*s1))x0dx0a {x0dx0a if((*ht)[i].weight<(*ht)[min].weight) x0dx0a min=i;x0dx0a }x0dx0a }x0dx0a *s2=min;x0dx0a}//构造哈夫曼树ht。w存放已知的n个权值x0dx0avoid CrtHuffmanTree(HuffmanTree *ht,int *w,int n)x0dx0a{x0dx0a int m,i,s1,s2;x0dx0a m=2*n-1;x0dx0a *ht=(HuffmanTree)malloc((m+1)*sizeof(HTNode));x0dx0a for(i=1; i<=n; i++) //1--n号存放叶子结点，初始化x0dx0a {x0dx0a (*ht)[i].weight=w[i];x0dx0a (*ht)[i].LChild=0;x0dx0a (*ht)[i].parent=0;x0dx0a (*ht)[i].RChild=0;x0dx0a }x0dx0a for(i=n+1; i<=m; i++)x0dx0a {x0dx0a (*ht)[i].weight=0;x0dx0a (*ht)[i].LChild=0;x0dx0a (*ht)[i].parent=0;x0dx0a (*ht)[i].RChild=0;x0dx0a } //非叶子结点初始化x0dx0a printf(" HuffmanTree: ");x0dx0a for(i=n+1; i<=m; i++) //创建非叶子结点，建哈夫曼树x0dx0a { x0dx0a //在(*ht)[1]~(*ht)[i-1]的范围内选择两个parent为0x0dx0a //且weight最小的结点，其序号分别赋值给s1、s2x0dx0a Select(ht,i-1,&s1,&s2);x0dx0a (*ht)[s1].parent=i;x0dx0a (*ht)[s2].parent=i;x0dx0a (*ht)[i].LChild=s1;x0dx0a (*ht)[i].RChild=s2;x0dx0a (*ht)[i].weight=(*ht)[s1].weight+(*ht)[s2].weight;x0dx0a printf("%d (%d, %d) ",(*ht)[i].weight,(*ht)[s1].weight,(*ht)[s2].weight);x0dx0a }x0dx0a printf(" ");x0dx0a} //哈夫曼树建立完毕//从叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码x0dx0avoid CrtHuffmanCode(HuffmanTree *ht, HuffmanCode *hc, int n)x0dx0a{x0dx0a char *cd;x0dx0a int i,start,p;x0dx0a unsigned int c;x0dx0a hc=(HuffmanCode *)malloc((n+1)*sizeof(char *)); //分配n个编码的头指针x0dx0a cd=(char *)malloc(n*sizeof(char)); //分配求当前编码的工作空间x0dx0a cd[n-1]=""; //从右向左逐位存放编码，首先存放编码结束符x0dx0a for(i=1; i<=n; i++) //求n个叶子结点对应的哈夫曼编码x0dx0a {x0dx0a start=n-1; //初始化编码起始指针x0dx0a for(c=i,p=(*ht)[i].parent; p!=0; c=p,p=(*ht)[p].parent) //从叶子到根结点求编码x0dx0a if( (*ht)[p].LChild==c) x0dx0a cd[--start]="0"; //左分支标0x0dx0a else x0dx0a cd[--start]="1"; //右分支标1x0dx0a hc[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个编码分配空间x0dx0a strcpy(hc[i],&cd[start]);x0dx0a }x0dx0a free(cd);x0dx0a for(i=1; i<=n; i++)x0dx0a printf("HuffmanCode of %3d is %s ",(*ht)[i].weight,hc[i]);x0dx0a printf(" ");x0dx0a}void main()x0dx0a{x0dx0a HuffmanTree HT;x0dx0a HuffmanCode HC;x0dx0a int *w,i,n,wei,m;x0dx0a printf(" n = " );x0dx0a scanf("%d",&n);x0dx0a w=(int *)malloc((n+1)*sizeof(int)); x0dx0a printf(" input the %d element"s weight: ",n); x0dx0a for(i=1; i<=n; i++)x0dx0a { x0dx0a printf("%d: ",i); x0dx0a fflush(stdin);x0dx0a scanf("%d",&wei);x0dx0a w[i]=wei;x0dx0a }x0dx0a CrtHuffmanTree(&HT,w,n);x0dx0a CrtHuffmanCode(&HT,&HC,n);x0dx0a}

一般来说，基于麦克风阵列的声源定位算法划分为三类：一是基于波束形成的方法；二是基于高分辨率谱估计的方法；三是基于声达时延差（TDOA）的方法。基于最大输出功率的可控波束形成技术Beamforming，它的基本思想就是将各阵元采集来的信号进行加权求和形成波束，通过搜索声源的可能位置来引导该波束，修改权值使得传声器阵列的输出信号功率最大。这种方法既能在时域中使用，也能在频域中使用。它在时域中的时间平移等价于在频域中的相位延迟。在频域处理中，首先使用一个包含自谱和互谱的矩阵，称之为互谱矩阵（Cross-Spectral Matrix，CSM）。在每个感兴趣频率之处，阵列信号的处理给出了在每个给定的空间扫描网格点上或每个信号到达方向（Direction ofArrival，DOA）的能量水平。因此，阵列表示了一种与声源分布相关联的响应求和后的数量。这种方法适用于大型麦克风阵列，对测试环境适应性强。GLFore的acam100就是这个原理。

是flash分区表，也在mtdpart.c同一函数中，第430行：printk (KERN_NOTICE "0x%08x-0x%08x : "%s" ", slave->offset, slave->offset + slave->mtd.size, slave->mtd.name);MTD体系结构：在linux中提供了MTD（Memory Technology Device，内存技术设备）系统来建立Flash针对linux的统一、抽象的接口引入MTD后，linux系统中的Flash设备驱动及接口可分为4层:设备节点MTD设备层MTD原始设备层硬件驱动层

BEAM3——二维弹性梁单元 单元描述： BEAM3 是一个轴向拉压和弯曲单元，每个节点有 3 个自由度：沿节点坐标系 x、y 方向的平动和绕 z 轴的转动。单元的详细特性请参考理论手册。其它的二维梁单元是塑性梁单元（BEAM23）和变截面非对称梁单元（BEAM54)。

操作系统：《操作系统概念》、《现代操作系统》数据结构：严版《数据结构（C语言版）》、《数据结构与算法分析》（Weiss著，有C/C++/Java描述的不同版本）编译原理：传说中的“龙书”、“虎书”和“鲸书”，全名记不清了可以自己搜一下。算法：《算法导论》、《算法设计与分析基础》（Levitin著）数据库：《数据库系统概念》软件工程：随意，反正得多做项目体会……以后可以看看《人月神话》

　　当今世界，据统计，亚洲女性的标准三围(胸、腰、臀)分别是84厘米、62厘米和86厘米。　　评定美胸的标准　　1.半球型、圆锥型的乳房是属于外形较理想的。　　2.乳房微微向上挺，厚约8-10厘米。　　3.乳晕大小不超过1元硬币，颜色红润粉嫩，与乳房皮肤有明显的分界线，婚后色素沉着为褐色。　　4.乳头应突出，不内陷，大小为乳晕直径的1/3。　　评定纤腰的标准　　1.腰身宽与窄都无所谓，但必须和整个身材配合适宜。中国传统审美崇尚细腰，唐代大诗人白居易有“杨柳小蛮腰”一说，后人以“杨柳腰”或“小蛮腰”来形容纤细柔美的腰身。　　2.腰身一定要轻盈灵活，走动时才能摇曳生姿，具有曲线玲珑之美。　　3.腰部线条紧致，皮肤不松弛，不能有一捏一大把的赘肉。　　评定美臀的标准　　1.臀部要有一点儿上翘，前凸后翘，是评定美臀的重要条件。　　2.整个臀部的大小要均衡，必须与身体比例配合，不是大就好，太小当然也不合格。　　3.臀部必须紧实浑圆，走起路来不可晃动得太厉害。　　4.皮肤白皙、细腻、有弹性，不能没有脂肪，但却恰到好处。　　[编辑本段]三围计算篇　　每一个女性都渴望有一副完满的身材，但什么样的身材才完美呢？你知道标准的三围是什么样的吗？如果不知道，那么你就看下面的公式，那就是你努力的目标！　　胸围=身高 X 0.51 ( 如:身高160cm的标准胸围=160cm X 0.51=81.6cm )　　腰围=身高 X 0.34 ( 如:身高160cm的标准腰围=160cm X 0.34=54.4cm )　　臀围=身高 X 0.542 ( 如:身高160cm的标准臀围=160cm X 0.542=86.72cm )　　美丽的身体人人都有，只是巧妙之处各有不同，所以所谓的标准身材并不是只强调高与瘦。简单地说，如果从头到脚是匀称的，不管多高，只要头部太大，就会造成整体上的不谐调；而如果你的身高只有150cm，但脸形大小合适、身材匀称，那就算是个比例标准的模特哦！　　依据下列步骤可以检测自己的身材。　　一、身材比例的计算步骤　　1． 判断脸形、头长：把头发全部往后梳起，抓起马尾，让脸部的轮廓线露出来，判定自己的脸形，再拿尺子由头顶到下巴（以光头的比例为准）测量一下脸的长度。　　2． 测量身高：量身高，要把头发压平、身体挺直才够准确。　　3． 计算比例：身高÷头长 = 头身（这就是所谓的身高比例标准）。　　例如：你身高159cm，头长20cm，那么159（身高）÷20（头长）=7.59（头身），四舍五入后，你可是标准的8头身哦！　　二、 标准三围的参考尺寸　　标准三围的尺寸可参考表1：　　表1　　身高 170cm 164cm 158cm 152cm　　胸围 88cm 86cm 84cm 80cm　　腰围 68cm 66cm 64cm 62cm　　臀围 94cm 90cm 86cm 82cm　　（注：1英寸=2.54cm）　　三、新时尚公式　　标准体重（kg）=（身高－100cm）×0.9　　标准臀围(cm)= 身高（cm）×0.54　　标准胸围(cm)= 身高（cm）×0.53　　标准腰围(cm)= 身高（cm）×0.37　　标准大腿长(cm)= 身高（cm）×0.3　　标准小腿长(cm)= 身高（cm）×0.26　　[编辑本段]三围历史篇　　【古代中国美女的三围标准】　　胸围：古代中国人对女性的胸围要求不高，对拥有一双丰满隆起的乳房的女性也颇不以为然。其实，古代男子欣赏的女性乳房是恰堪一握的丁香乳。　　腰围：公元前6世纪的楚灵王偏爱细腰女子；与楚襄王同时的楚人宋玉，在其《登徒子好色赋》中，对那位漂亮的“东家之子”也有“腰如束素”的描写有所偏爱。不过，纤细腰身，似乎只是荆楚一带的风尚。而对大多数中国人来说，只要腰身和整个身材配合得宜，宽与窄都无所谓，粗腰名曰“水桶腰”，细腰美其曰“杨柳腰”、“小蛮腰”。不过，腰无论粗细，一定要轻盈灵活，走动时才能摇曳生姿，具有“曲线玲珑”之美。　　臀围：它的丰满与否，成为古代中国美女的重要件之一。其原因，中国人认为臀部浑圆的女人会多生孩子。在“不孝有三，无后为大”的古代农业社会里，肥臀自有其重要性。

可以啊，这是matlab的一个例程，读取的图片就是灰度图像，运行没问题 ref = imread("pout.tif"); H = fspecial("Gaussian",[11 11],1.5); A = imfilter(ref,H,"replicate"); subplot(1,2,1); imshow(ref); title("Reference Image"); subplot(1,2,2); imshow(A); title("Blurred Image"); [ssimval, ssimmap] = ssim(A,ref); fprintf("The ssim value is %0.4f. ",ssimval); figure, imshow(ssimmap,[]); title(sprintf("ssim Index Map - Mean ssim Value is %0.4f",ssimval));

　　摘 要： 为准确地提取出SAR图像中溢油区域边缘轮廓信息，提出一种融合分水岭及canny算子的SAR图像边缘检测算法。该算法首先使用形态学重建技术对前景图象进行标记，并进行开关操作，去除边缘无关信息，然后对前景进行区分操作。利用分水岭算法及canny算子较为精确地提取出溢油区域边缘轮廓信息并用MATALAB仿真实验，结果表明，与经典的边缘检测方法相比，该方法在精确定位图像边缘的同时能更精确、更完整地检测出目标的边缘特征。 　　关键词： SAR图像；分水岭算法；溢油；MATALAB；边缘轮廓检测 　　0 前言 　　海上溢油现象严重影响海洋生态环境，因此对海洋表面进行实时动态监测成为必要。合成孔径雷达（SAR）具有高分辨率、大面积数据获取能力，全天候、全天时数据获取能力和一定的穿透植被、遮盖物的能力[1]。因此被应用于海洋表面的溢油监测，本文则选取合成孔径雷达所监测到的墨西哥湾溢油图像进行边缘检测处理，得到了良好的溢油区域的边缘轮廓信息，为以后SAR图像特征的提取及计算机自动识别SAR图像目标区域奠定了基础。目前已有许多边缘检测算子，如Sobel算子、Prewitt算子、Robert算子、Log算子、Canny算子等[1]。这些传统的算子对SAR图像进行检测往往会使得目标的边缘改变，不能够获得连续的边缘轮廓信息，给后续处理带来困难。而融合其中的Canny算子和标记分水岭分割算法能够较好的获得准确连续的边缘轮廓信息。 　　1 SAR图像预处理 　　由于在获取溢油区域的SAR图像的过程中存在各种干扰，所获得的SAR原始图像当中存在相干斑噪声及几何失真和辐射失真，因此必须对其进行一系列滤波及矫正预处理。本文则采用NEST 3C软件对原始SAR图像进行几何矫正、辐射矫正及斑点滤波，其中斑点滤波采用3*3均值滤波和7*7gamma滤波。对预处理完的图像则使用ENVI 4.7软件对其进行数据重采样获得本文所要处理的SAR图像。 　　2 基于Canny算子的SAR图像边缘检测 　　Canny边缘检测算子是一类最优边缘检测算子，他在许多图像处理领域得到了广泛的应用[2]。Canny算子具有定位能力强、低误判率、抑制虚假边缘等优点[3]。但是Canny算子是针对加性噪声模型的，因此在SAR图像的边缘检测时容易使边缘产生不连续性。 　　3 基于标记分水岭算法的SAR图像边缘检测 　　分水岭边缘检测方法，是一种基于拓扑理论的数学形态学的检测方法，其基本思想是把图像看作是测地学上的拓扑地貌，其中灰度值对应着地形高度值[2]。每一个小的局部区域及其影响区域称为集水盆地，集水盆地的边界则形成分水岭。分水岭算法就是向集水盆地不断灌入水的过程，在两个集水盆地汇合处形成山脊，即形成分水岭。 找出分水岭便找出边缘信息。 　　标记分水岭图像分割算法[4]能够将图像中的目标区域与非目标区域紧密连接的目标区域分割出来，能够分离出弱边缘，且分水岭变换产生完整的边界，这样就避免了边界连接的后处理。但是由于噪声和纹理细节会带来过分割问题，另外，在分割过程中较少用到边界特征信息，使得图像的过分割问题比较突出，容易产生虚假边缘。 　　4 组合两种算法的边缘检测算子及其MATALAB实现 　　为了使标记分水岭分割算法能够用于SAR图像边缘检测并使其具有连续性且边缘定位准确，又能抑制虚假边缘。可在标记分水岭算法的基础上融合canny算子，形成一种良好地描述溢油区域边界信息的算子。 　　其实现过程为：通过标记分水岭分割算法标记非溢油区和边界区为前景区，溢油区为背景区，再使用canny边缘检测算子进行边缘检测分离出非溢油区和边界区，从而得到较为完整的溢油区域边缘轮廓信息。 　　其MATALAB处理结果及具体程序代码： 　　MATALAB程序代码为： 　　clear ; 　　[I,p,t]=freadenvi_image("F:ENVISAT-ASA_IMP_1PNCUH20060524_141948_000000162048_00025_22123_0430.N1_Calib_Spk_Spk_reprojected.dataSigma0_VV(4122-4653)(5898-6500)"); %读取envi图像 　　subplot(2,2,1) 　　imshow(I),title("预处理完图像") 　　hy = fspecial("log");%log算子 　　hx = hy"; 　　Iy = imfilter(double(I), hy, "replicate"); 　　Ix = imfilter(double(I), hx, "replicate"); 　　gradmag = sqrt(Ix.^2 + Iy.^2); 　　L = watershed(gradmag); 　　se = strel("disk", 45); 　　Io = imopen(I, se); 　　Ie = imerode(I, se); 　　Iobr = imreconstruct(Ie, I); 　　Ioc = imclose(Io, se); 　　Iobrd = imdilate(Iobr, se); 　　Iobrcbr = imreconstruct(imcomplement(Iobrd),... 　　imcomplement(Iobr)); 　　Iobrcbr = imcomplement(Iobrcbr); 　　fgm = imregionalmax(Iobrcbr); 　　I2 = I; 　　I2(fgm) = 255; 　　se2 = strel(ones(1,1)); 　　fgm2 = imclose(fgm, se2); 　　fgm3 = imerode(fgm2, se2); 　　fgm4 = bwareaopen(fgm3, 20); 　　I3 = I; 　　I3(fgm4) = 255; 　　bw = im2bw(Iobrcbr, graythresh(Iobrcbr)); 　　D = bwdist(bw); 　　DL = watershed(D); 　　bgm = DL == 0; 　　gradmag2 = imimposemin(gradmag, bgm | fgm4); 　　L = watershed(gradmag2); 　　I4 = I; 　　I4(imdilate(L == 0, ones(3, 3)) | bgm | fgm4) = 255; 　　subplot(2,2,2) 　　imshow(I4)%突出前景及边界 　　title("分水岭算法边缘检测") 　　subplot(2,2,3) 　　Y = edge(I,"canny"); 　　imshow(Y),title("canny边缘检测"); 　　subplot(2,2,4) 　　Z = edge(I4,"canny"); 　　imshow(Z),title("融合边缘检测"); 　　5 结论 　　1）传统的边缘检测方法能够获取目标的一些边缘特征，但提取出的目标边缘特征存在断裂及目标定位不准确的情况。此外，原始方法提取的边缘特征在细化描述边缘轮廓时不能实现有效检测。 　　2）利用本文方法提取的边缘特征清晰、连续，能够较好的描述原始SAR图像中溢油区与非溢油区分界处边缘轮廓信息。 　　参考文献： 　　[1]张静、王国宏、刘福太，基于正则化方法的SAR图像分割及目标边缘检测算法，吉林大学学报（工学版），2008年1月第38卷第1期. 　　[2]张德丰，详解MATALAB数字图像处理，电子工业出版社，2010年. 　　[3]安成锦、杜琳琳、王卫华、陈曾平，基于融合边缘检测的SAR图像线性特征提取算法，电子与信息学报，第31卷第6期. 　　[4]高丽、杨树元、李海强，一种基于标记的分水岭图像分割新算法，中国图象图形学报，2007年6月第12卷第6期.

clear,clc%三种方法进行分水岭分割%读入图像filename="sar1.bmp";f=imread(filename);Info=imfinfo(filename);if Info.BitDepth>8 f=rgb2gray(f);endfigure,mesh(double(f));%显示图像，类似集水盆地%方法1：一般分水岭分割，从结果可以看出存在过分割问题b=im2bw(f,graythresh(f));%二值化,注意应保证集水盆地的值较低（为0），否则就要对b取反d=bwdist(b); %求零值到最近非零值的距离，即集水盆地到分水岭的距离 l=watershed(-d); %matlab自带分水岭算法，l中的零值即为风水岭w=l==0; %取出边缘g=b&~w; %用w作为mask从二值图像中取值figuresubplot(2,3,1),imshow(f);subplot(2,3,2),imshow(b);subplot(2,3,3),imshow(d);subplot(2,3,4),imshow(l);subplot(2,3,5),imshow(w);subplot(2,3,6),imshow(g);%方法2：使用梯度的两次分水岭分割，从结果可以看出还存在过分割问题（在方法1的基础上改进）h=fspecial("sobel");%获得纵方向的sobel算子fd=double(f);g=sqrt(imfilter(fd,h,"replicate").^2+imfilter(fd,h","replicate").^2);%使用sobel算子进行梯度运算l=watershed(g);%分水岭运算wr=l==0; g2=imclose(imopen(g,ones(3,3)),ones(3,3));%进行开闭运算对图像进行平滑l2=watershed(g2);%再次进行分水岭运算wr2=l2==0;f2=f;f2(wr2)=255;figuresubplot(2,3,1),imshow(f);subplot(2,3,2),imshow(g);subplot(2,3,3),imshow(l);subplot(2,3,4),imshow(g2);subplot(2,3,5),imshow(l2);subplot(2,3,6),imshow(f2);%方法3：使用梯度加掩模的三次分水岭算法（在方法2的基础上改进）h=fspecial("sobel");%获得纵方向的sobel算子fd=double(f);g=sqrt(imfilter(fd,h,"replicate").^2+imfilter(fd,h","replicate").^2);%使用sobel算子进行梯度运算l=watershed(g);%分水岭运算wr=l==0; rm=imregionalmin(g); %计算图像的区域最小值定位，该函数仅仅是用来观察为何分水岭算法产生这么多集水盆地im=imextendedmin(f,2);%上面仅是产生最小值点，而该函数则是得到最小值附近的区域，此处的附近是相差2的区域fim=f; fim(im)=175; %将im在原图上标识出，用以观察 lim=watershed(bwdist(im));%再次分水岭计算em=lim==0;g2=imimposemin(g,im|em);%在梯度图上标出im和em，im是集水盆地的中心，em是分水岭l2=watershed(g2); %第三次分水岭计算f2=f;f2(l2==0)=255; %从原图对分水岭进行观察figuresubplot(3,3,1),imshow(f);subplot(3,3,2),imshow(g);subplot(3,3,3),imshow(l);subplot(3,3,4),imshow(im);subplot(3,3,5),imshow(fim);subplot(3,3,6),imshow(lim);subplot(3,3,7),imshow(g2);subplot(3,3,8),imshow(l2)subplot(3,3,9),imshow(f2);

DIT先乘以旋转因子后蝶形运算DIF先蝶形运算后乘以旋转因子

太多了太多了 只贴一个把%Retinex的MSR实现图像增强的代码，可运行，f=imread("c.jpg");fr=f(:, :, 1); fg=f(:, :, 2); fb=f(:, :, 3);%RGB通道mr=mat2gray(im2double(fr)); mg=mat2gray(im2double(fg)); mb=mat2gray(im2double(fb));%数据类型归一化alf1=1458; %定义标准差alf=a^2/2 a=54n=161;%定义模板大小n1=floor((n+1)/2);%计算中心for i=1:n for j=1:n b(i,j) =exp(-((i-n1)^2+(j-n1)^2)/(4*alf1))/(pi*alf1); %高斯函数 endendnr1 = imfilter(mr,b,"conv", "replicate");ng1 = imfilter(mg,b,"conv", "replicate");nb1 = imfilter(mb,b,"conv", "replicate");%卷积滤波ur1=log(nr1); ug1=log(ng1); ub1=log(nb1);tr1=log(mr);tg1=log(mg);tb1=log(mb);yr1=(tr1-ur1)/3;yg1=(tg1-ug1)/3;yb1=(tb1-ub1)/3;alf2=53.38; %定义标准差alf=a^2/2 a=10.3325x=31;%定义模板大小x1=floor((n+1)/2);%计算中心for i=1:n for j=1:n a(i,j) =exp(-((i-n1)^2+(j-n1)^2)/(4*alf2))/(6*pi*alf2); %高斯函数 endendnr2 = imfilter(mr,a,"conv", "replicate");ng2 = imfilter(mg,a,"conv", "replicate");nb2 = imfilter(mb,a,"conv", "replicate");%卷积滤波ur2=log(nr2); ug2=log(ng2); ub2=log(nb2);tr2=log(mr);tg2=log(mg);tb2=log(mb);yr2=(tr2-ur2)/3;yg2=(tg2-ug2)/3;yb2=(tb2-ub2)/3;alf3=13944.5; %定义标准差alf=a^2/2 a=167l=501;%定义模板大小l1=floor((n+1)/2);%计算中心for i=1:n for j=1:n e(i,j) =exp(-((i-n1)^2+(j-n1)^2)/(4*alf3))/(4*pi*alf3); %高斯函数 endendnr3 = imfilter(mr,e,"conv", "replicate");ng3 = imfilter(mg,e,"conv", "replicate");nb3 = imfilter(mb,e,"conv", "replicate");%卷积滤波ur3=log(nr3); ug3=log(ng3); ub3=log(nb3);tr3=log(mr);tg3=log(mg);tb3=log(mb);yr3=(tr3-ur3)/3;yg3=(tg3-ug3)/3;yb3=(tb3-ub3)/3;dr=yr1+yr2+yr3;dg=yg1+yg2+yg3;db=yb1+yb2+yb3;cr=im2uint8(dr); cg=im2uint8(dg); cb=im2uint8(db);z=cat(3, cr, cg, cb); figure, imshow(z)

FFT是快速傅里叶变换（ Fast Fourier Transform ）DSP是数字信号处理 （ Digital Signal Processing ）

我只能给你一个fft算法，流程图说起来有点复杂，可以matlab里面的函数tic（开启时钟）t=toc（关闭时钟）t就是运算过程的时间当然tic放程序开始，toc放结尾，来分析之即可function d=lxfft(x)n=length(x);if n>2 for i=0:n/2-1 x1(i+1)=x(2*i+1); x2(i+1)=x(2*i+2); end X1=lxfft(x1); X2=lxfft(x2); for i=0:n/2-1 X2(i+1)= X2(i+1)*exp(-j*2*pi/n*i);//旋转因子 d(i+1)=X1(i+1)+X2(i+1); d(i+n/2+1)=X1(i+1)-X2(i+1); end else d(1)=x(1)+x(2); d(2)=x(1)-x(2);endend

我给你我写的程序吧： x=ones(1,128); %输入的信号，自己可以改变 %整体运用原位计算 m=nextpow2(x);N=2^m; % 求x的长度对应的2的最低幂次m if length(x)<N x=[x,zeros(1,N-length(x))]; % 若x的长度不是2的幂，补零到2的整数幂 end nxd=bin2dec(fliplr(dec2bin([1:N]-1,m)))+1; % 求1:2^m数列序号的倒序 y=x(nxd); % 将x倒序排列作为y的初始值 for mm=1:m % 将DFT作m次基2分解,从左到右，对每次分解作DFT运算,共做m级蝶形运算，每一级都有2^(mm-1)个蝶形结 Nz=2^mm;u=1; % 旋转因子u初始化为WN^0=1 WN=exp(-i*2*pi/Nz); % 本次分解的基本DFT因子WN=exp(-i*2*pi/Nz) for j=1:Nz/2 % 本次跨越间隔内的各次蝶形运算,在进行第mm级运算时需要2^(mm-1)个 蝶形 for k=j:Nz:N % 本次蝶形运算的跨越间隔为Nz=2^mm kp=k+Nz/2; % 蝶形运算的两个因子对应单元下标的关系 t=y(kp)*u; % 蝶形运算的乘积项 y(kp)=y(k)-t; % 蝶形运算 y(k)=y(k)+t; % 蝶形运算 end u=u*WN; % 修改旋转因子,多乘一个基本DFT因子WN end end y y1=fft(x) %自己编的FFT跟直接调用的函数运算以后的结果进行对比因为输入是128个1所以结果就是这样，我最后不是有结果比对么？相减是全0的话不就对了么！？，你可以改变输入，多选择几组值来检验．

T/FFT的发展历史离散傅里叶变换（Discrete Fourier Transform，DFT）是数字信号处理最重要的基石之一，也是对信号进行分析和处理时最常用的工具之一。在200多年前法国数学家、物理学家傅里叶提出后来以他名字命名的傅里叶级数之后，用DFT这个工具来分析信号就已经为人们所知。历史上最伟大的数学家之一。 欧拉是第一个使用“函数”一词来描述包含各种参数的表达式的人，例如：y = f(x)。他是把微积分应用于物理学的先驱者之一。 给出了一个用实变量函数表示傅立叶级数系数的方程； 用三角级数来描述离散声音在弹性媒介中传播，发现某些函数可以通过余弦函数之和来表达。 但在很长时间内，这种分析方法并没有引起更多的重视，最主要的原因在于这种方法运算量比较大。直到1965年，Cooley和Tukey在《计算机科学 》发表著名的《机器计算傅立叶级数的一种算法》论文，FFT才开始大规模应用。那个年代，有个肯尼迪总统科学咨询委员会。其中有项研究主题是，对苏联核测试进行检测，Tukey就是其中一员。美国/苏联核测试提案的批准，主要取决于不实地访问核测试设施而做出检测的方法的发展。其中一个想法是，分析离海岸的地震计情况，这种计算需要快速算法来计算DFT。其它应用是国家安全，如用声学探测远距离的核潜艇。所以在军事上，迫切需要一种快速的傅立叶变换算法，这也促进了FFT的正式提出。FFT的这种方法充分利用了DFT运算中的对称性和周期性，从而将DFT运算量从N2减少到N*log2N。当N比较小时，FFT优势并不明显。但当N大于32开始，点数越大，FFT对运算量的改善越明显。比如当N为1024时，FFT的运算效率比DFT提高了100倍。在库利和图基提出的FFT算法中，其基本原理是先将一个N点时域序列的DFT分解为N个1点序列的DFT，然后将这样计算出来的N个1点序列DFT的结果进行组合，得到最初的N点时域序列的DFT值。实际上，这种基本的思想很早就由德国伟大的数学家高斯提出过，在某种情况下，天文学计算（也是现在FFT应用的领域之一）与等距观察的有限集中的行星轨道的内插值有关。由于当时计算都是靠手工，所以产生一种快速算法的迫切需要。 而且，更少的计算量同时也代表着错误的机会更少，正确性更高。高斯发现，一个富氏级数有宽度N=N1*N2，可以分成几个部分。计算N2子样本DFT的N1长度和N1子样本DFT的N2长度。只是由于当时尚欠东风——计算机还没发明。在20世纪60年代，伴随着计算机的发展和成熟，库利和图基的成果掀起了数字信号处理的革命，因而FFT发明者的桂冠才落在他们头上。之后，桑德（G.Sand）-图基等快速算法相继出现，几经改进，很快形成了一套高效运算方法，这就是现在的快速傅立叶变换（FFT）。这种算法使DFT的运算效率提高1到2个数量级，为数字信号处理技术应用于各种信号的实时处理创造了良好的条件，大大推进了数学信号处理技术。1984年，法国的杜哈梅（P.Dohamel）和霍尔曼（H.Hollamann）提出的分裂基块快速算法，使运算效率进一步提高。库利和图基的FFT算法的最基本运算为蝶形运算，每个蝶形运算包括两个输入点，因而也称为基-2算法。在这之后，又有一些新的算法，进一步提高了FFT的运算效率，比如基-4算法，分裂基算法等。这些新算法对FFT运算效率的提高一般在50%以内，远远不如FFT对DFT运算的提高幅度。从这个意义上说，FFT算法是里程碑式的。可以说，正是计算机技术的发展和FFT的出现，才使得数字信号处理迎来了一个崭新的时代。除了......

　　有理数的运算法则，主要是指有理数的四则运算法则以及非负整数指数的乘方的运算。　　一、有理数的加法法则：　　1、同号两数相加，取相同的符号，并将绝对值相加；　　2、异号两数相加，取绝对值较大的数的符号，并用较大的绝对值减去较小的绝对值；　　3、任何有理数与0相加，仍得它本身；　　4、互为相反数的和等于0.　　二、有理数的减法法则：减去一个数相当于加上这个数的相反数.　　注：加减混合运算时，先将所有运算统一成加法，再运用加法交换律和结合律运算。　　　　三、有理数的乘法法则：　　1、同号得正，异号得负，再把绝对值相乘；　　2、任何有理数与0的积等于0；　　3、任何有理数与1的积，仍得它本身；　　4、互为倒数的积等于1.　　四、有理数的除法法则：除以一个非零的数相当于乘以这个数的倒数　　注：乘除混合运算时，先将所有运算统一成乘法，再运用乘法交换律和结合律运算。当负因数的个数为偶数时，结果得正；当负因数的个数为奇数时，结果得负.　　五、有理数的四则运算法则：　　1、有括号先算先算括号，按小括号、中括号、大括号的顺序运算；　　2、先乘除，后加减；　　3、同级运算，从左向右运算；　　4、善用乘法分配律.　　　　六、有理数的乘方：　　1、正数的乘方是正数；　　2、负数的偶数次方是正数，负数的奇数次方是负数；　　3、0的任何非零次方等于0；　　4、1的任何次方等于1；　　5、任何非零的有理数的0次方等于1.　　六、有理数的混合运算：　　1、有括号先算括号；　　2、有乘方再算乘方；　　3、然后接四则运算法则运算.　　题目千变万化，以上的法则是最基本的依据，灵活运用，还要靠平时多积累经验。

有理数的加减乘除混合运算，如无括号指出先做什么运算，按照“先乘除，后加减”的顺序进行，如果是同级运算，则按照从左到右的顺序依次计算。在没有括号的算式里，如果只有加减法或者只有乘除法，要从左往右依次计算。在没有括号的算式里，如果既有乘除法又有加减法，要先算乘除法，再算加减法。有理数的认识有理数为整数（正整数、0、负整数）和分数的统称。正整数和正分数合称为正有理数，负整数和负分数合称为负有理数。因而有理数集的数可分为正有理数、负有理数和零。由于任何一个整数或分数都可以化为十进制循环小数，反之，每一个十进制循环小数也能化为整数或分数，因此，有理数也可以定义为十进制循环小数。以上内容参考：百度百科-有理数

(1)有理数的加法法则：1.同号两数相加，和取相同的符号，并把绝对值相加；2.绝对值不等的异号两数相加，和取绝对值较大的加数的符号，并用较大的绝对值减去较小的绝对值；3.一个数与零相加仍得这个数；4.两个互为相反数相加和为零。⑵有理数的减法法则：减去一个数等于加上这个数的相反数。补充：去括号与添括号：去括号法则：括号前是“+”号时，将括号连同它前边的“+”号去掉，括号内各项都不变；括号前是“－”号时，将括号连同它前边的“－”去掉，括号内各项都要变号。添括号法则：在“+”号后边添括号，括到括号内的各项都不变；在“－”号后边添括号，括到括号内的各项都要变号。⑶有理数的乘法法则：①两数相乘，同号得正，异号得负，并把绝对值相乘；②任何数与零相乘都得零；③几个不等于零的数相乘，积的符号由负因数的个数决定，当负因数有奇数个数，积为负；当负因数的个数为偶数个时，积为正；④几个有理数相乘，若其中有一个为零，积就为零。⑷有理数的除法法则：法则一：两个有理数相除，同号得正，异号得负，并把绝对值相除；法则二：除以一个数等于乘以这个数的倒数。⑸有理数的乘方：求n个相同因数的积的运算，叫做乘方，乘方的给果叫做幂。正数的任何次幂都是正数；负数的奇次幂是负数，负数的偶次幂是正数。⑹有理数的运算顺序：有理数的混合运算法则即先算乘方或开方，再算乘法或除法，后算加法或减法。有括号时、先算小括号里面的运算，再算中括号，然后算大括号。[5*（4-5+5）]÷5=（5*4）÷5=4⑺运算律：①加法的交换律：a+b=b+a；②加法的结合律：(a+b)+c=a+(b+c)；③乘法的交换律：ab=ba；④乘法的结合律：(ab)c=a(bc)；⑤乘法对加法的分配律：a(b+c)=ab+ac；注：除法没有分配律。

负数的奇次幂是负数，负数的偶次幂是正数，0的任何次幂都是0

　　有理数的运算法则，主要是指有理数的四则运算法则以及非负整数指数的乘方的运算。　　一、有理数的加法法则：　　1、同号两数相加，取相同的符号，并将绝对值相加；　　2、异号两数相加，取绝对值较大的数的符号，并用较大的绝对值减去较小的绝对值；　　3、任何有理数与0相加，仍得它本身；　　4、互为相反数的和等于0.　　二、有理数的减法法则：减去一个数相当于加上这个数的相反数.　　注：加减混合运算时，先将所有运算统一成加法，再运用加法交换律和结合律运算。　　　　三、有理数的乘法法则：　　1、同号得正，异号得负，再把绝对值相乘；　　2、任何有理数与0的积等于0；　　3、任何有理数与1的积，仍得它本身；　　4、互为倒数的积等于1.　　四、有理数的除法法则：除以一个非零的数相当于乘以这个数的倒数　　注：乘除混合运算时，先将所有运算统一成乘法，再运用乘法交换律和结合律运算。当负因数的个数为偶数时，结果得正；当负因数的个数为奇数时，结果得负.　　五、有理数的四则运算法则：　　1、有括号先算先算括号，按小括号、中括号、大括号的顺序运算；　　2、先乘除，后加减；　　3、同级运算，从左向右运算；　　4、善用乘法分配律.　　　　六、有理数的乘方：　　1、正数的乘方是正数；　　2、负数的偶数次方是正数，负数的奇数次方是负数；　　3、0的任何非零次方等于0；　　4、1的任何次方等于1；　　5、任何非零的有理数的0次方等于1.　　六、有理数的混合运算：　　1、有括号先算括号；　　2、有乘方再算乘方；　　3、然后接四则运算法则运算.　　题目千变万化，以上的法则是最基本的依据，灵活运用，还要靠平时多积累经验。

绝对值几何意义：数轴上一个数到原点的距离代数意义：负数的相反数，非负数本身乘除法：同号为正，异号为负，有0为0

　　有理数的运算法则，主要是指有理数的四则运算法则以及非负整数指数的乘方的运算。　　一、有理数的加法法则：　　1、同号两数相加，取相同的符号，并将绝对值相加；　　2、异号两数相加，取绝对值较大的数的符号，并用较大的绝对值减去较小的绝对值；　　3、任何有理数与0相加，仍得它本身；　　4、互为相反数的和等于0.　　二、有理数的减法法则：减去一个数相当于加上这个数的相反数.　　注：加减混合运算时，先将所有运算统一成加法，再运用加法交换律和结合律运算。　　　　三、有理数的乘法法则：　　1、同号得正，异号得负，再把绝对值相乘；　　2、任何有理数与0的积等于0；　　3、任何有理数与1的积，仍得它本身；　　4、互为倒数的积等于1.　　四、有理数的除法法则：除以一个非零的数相当于乘以这个数的倒数　　注：乘除混合运算时，先将所有运算统一成乘法，再运用乘法交换律和结合律运算。当负因数的个数为偶数时，结果得正；当负因数的个数为奇数时，结果得负.　　五、有理数的四则运算法则：　　1、有括号先算先算括号，按小括号、中括号、大括号的顺序运算；　　2、先乘除，后加减；　　3、同级运算，从左向右运算；　　4、善用乘法分配律.　　　　六、有理数的乘方：　　1、正数的乘方是正数；　　2、负数的偶数次方是正数，负数的奇数次方是负数；　　3、0的任何非零次方等于0；　　4、1的任何次方等于1；　　5、任何非零的有理数的0次方等于1.　　六、有理数的混合运算：　　1、有括号先算括号；　　2、有乘方再算乘方；　　3、然后接四则运算法则运算.　　题目千变万化，以上的法则是最基本的依据，灵活运用，还要靠平时多积累经验。

(1)有理数的加法法则：1.同号两数相加，和取相同的符号，并把绝对值相加；2.绝对值不等的异号两数相加，和取绝对值较大的加数的符号，并用较大的绝对值减去较小的绝对值；3.一个数与零相加仍得这个数；4.两个互为相反数相加和为零。⑵有理数的减法法则：减去一个数等于加上这个数的相反数。补充：去括号与添括号：去括号法则：括号前是“+”号时，将括号连同它前边的“+”号去掉，括号内各项都不变；括号前是“－”号时，将括号连同它前边的“－”去掉，括号内各项都要变号。添括号法则：在“+”号后边添括号，括到括号内的各项都不变；在“－”号后边添括号，括到括号内的各项都要变号。⑶有理数的乘法法则：①两数相乘，同号得正，异号得负，并把绝对值相乘；②任何数与零相乘都得零；③几个不等于零的数相乘，积的符号由负因数的个数决定，当负因数有奇数个数，积为负；当负因数的个数为偶数个时，积为正；④几个有理数相乘，若其中有一个为零，积就为零。⑷有理数的除法法则：法则一：两个有理数相除，同号得正，异号得负，并把绝对值相除；法则二：除以一个数等于乘以这个数的倒数。⑸有理数的乘方：求n个相同因数的积的运算，叫做乘方，乘方的给果叫做幂。正数的任何次幂都是正数；负数的奇次幂是负数，负数的偶次幂是正数。⑹有理数的运算顺序：有理数的混合运算法则即先算乘方或开方，再算乘法或除法，后算加法或减法。有括号时、先算小括号里面的运算，再算中括号，然后算大括号。[5*（4-5+5）]÷5=（5*4）÷5=4⑺运算律：①加法的交换律：a+b=b+a；②加法的结合律：(a+b)+c=a+(b+c)；③乘法的交换律：ab=ba；④乘法的结合律：(ab)c=a(bc)；⑤乘法对加法的分配律：a(b+c)=ab+ac；注：除法没有分配律。

刚看到这个标题的时候，你可能会感到非常疑惑，算法怎么设计人生？这也是这本《人生算法》告诉我的道理。 首先，我们先从一个游戏开始。你现在中了一个大奖，你前面有两个按钮：按下第一个按钮，你可以马上拿走100万；按下第二个按钮，你有50%的概率获得一亿，也有50%的概率什么都没有，这两个按钮，只能选择一个，你会选择哪个？ 第一个按钮价值是100万，第二个按钮根据概率计算期望值值5000万，但是即便如此在生活还是会很多人选择第一个按钮，因为他们不愿意承受什么都拿不到的风险。那是否还有第三个选择吗？事实上是有的。 往前一步，你可以选择将第二个按钮以2000万的价格卖给愿意承担风险的人，这样你就能赚2000万，而不是100万。 再往前一步，你可以卖掉这个选择权，以100万首付卖给别人，同时签订合同：如果他中了一亿那分给你5000万，那这样你就有可能获益5100万 往前走三步，你可以将这个变成彩票，两元一张，印两亿张，算上头奖一亿，你还能赚三亿。 ...... 这个算法在人生中只是很小的一块，面对复杂的人生，我需要纠获得一项能力：扑克高手的决策能力，来应对不确定的人生。在某种意义上，我们每个人都在和命运对赌。 待解决的现实世界的问题分为可计算和不可计算两部分。对于可计算的部分，你要寻找最小化风险、最大化收益的下注方式，对于不可计算的部分，再精确的计算也无法消除不确定性，面对这部分问题，模糊的精确比精确的模糊更重要。 冲动： 面对可计算的问题，要像阿尔法围棋一样，兼顾直觉和理性。 弗洛伊德说：“人是一种受本能愿望支配的低能弱智的生物。”完美决策=直觉+经验+数据。那些不需要基本功和苦功夫就能让人修炼出惊人直觉的领域，基本都是玄学。 我们常常会认为围棋高手的计算能力一定非常强，一眼能计算到很远的地方，但心理学家发现，顶尖棋手的计划能力和相对弱的棋手的计算能力区别并不大。围棋大师吴清源在被人问道“你会目算多少步”的时候，同样认为不用看那么远，也能下出好棋。 围棋高手的厉害之处在于他们的直觉好，能够快速抓住重点，找到最有可能性的那几手棋，然后通过计算选出最优的一手。高手的这种直觉，正是通过大量理性的训练和实战获得的。把这个思路做到极致的，不是哪个人，而是AI——阿尔法围棋。要知道，围棋的变化数量比宇宙中所有的原子加起来还多，它和象棋不一样。因此，机器无法仅凭强大的计算能力，用穷举法在围棋赛场打败人类。 也就是说，阿尔法围棋的决策模式是先用直觉思维选定范围，再用理性思维逐个分析。它独特的算法思路把理性思维和直觉思维的效用发挥到了极致。 创造时靠直觉，决策时靠算法。特斯拉说：“我们小时候做事纯粹靠直觉，也就是那种生动而又散漫的想象力之火花。随着年龄的增长，理性呈现出来，我们做事越来越系统化和工于设计。但那些早期的冲动，虽其效用没有立竿见影，但却在我们的人生中占据重要位置，并且可能在很大程度上塑造我们的命运。” 模糊的精确好过精确的模糊。这种直觉，本质上是一种大局观。 婚姻的算法 姻缘是奇妙的东西，体现了世界的随机性：即使最理性的人，也可能要靠运气寻找另一半。 请你想象一个带花园的房子，并尝试用它来形容一个人内心的开放程度：最外面的大门是花园的门，然后是房子的大门，最后是卧室的门。有的人花园大门敞开，但你很难进入房子的大门。这就像是在社交场合上遇到的某个人，表面上看，他很热情，但你很难与之深交。有人的花园大门紧闭，房子的大门也不轻易向人敞开，可一旦你穿过外层的两扇门，他恨不得立马把卧室的门也为你敞开。这类人平时很内向，看起来拒人于千里之外，但别人稍微对他真诚点儿，他就恨不得把心掏出来。 “脱单”的正确做法：看好卧室的门，虚掩房子的大门，热情敞开花园的大门。不要见到心动的异性就敞开心扉，同时也不能太封闭，把最外面的花园大门关得死死的。 那对于两个已经非常熟悉的人，要怎么经营长期关系。书中给出了一个新词”口厌感“。什么叫口厌感呢？拿可口可乐来说，我们且不讨论它是否健康，而要关注它的一个特点——可口可乐几乎没有什么味觉残留。你今天喝完一瓶可口可乐，明天再喝也不会觉得腻。可乐的“口厌感”很低，只有这样，你才可能天天喝，它也因此成为高频消费产品。能让你多喝一些的决定性因素，不是好喝的峰值有多高，而是味觉残留的峰值有多低。 一开始，两个人的关系会特别好，但时间一长，会出现各种各样的问题，两个人的关系会越来越混乱。我们应该通过长时间相处，要能判断对方在某个时间节点的状态，并根据状态进行相应调整。如果对方很坚决，出于稳定，我们就要把自己调整得随和一点。如果对方现在很没主见，我们就最好把自己调节得坚定一点。如果在一段关系中，双方能自如地进行调节，就会形成默契。 所以，双方在一段理想的关系中最好能形成一种“十字锁扣”的结构。也就是说，一个外柔内刚的人遇到一个外刚内柔的人。你强硬的时候，我柔和，你内向的时候，我外向。相互调节，问题总会有解，这样的婚姻也就更长久。 人生中还有许许多多的困难和算法。书中一共将人生分为九段和十八关。九关作为提升自己的，分别为闭环、切换、内控、重启、增长、内核、复利、愿景和涌现。重在提升自己的内在能力。十八关分别为片面、狭隘、模糊。侥幸、宿命、追悔、非理性、冲动、犹豫、武断、情面、霉运、孤独、爆仓、迷信、无知、衰朽和贪婪，重在挑战本性。 不确定性一方面会带来意外，另一方面也给我们的生活平添了刺激，并赋予它意义。我们可能忽视了人生的另一个大敌，就是我们追求的确定性。确定性让我们感到安心，但日复一日的生活方式也显得非常无趣，一眼望到了头，更可怕的是意义感的丧失。 我们需要每次都努力做正确的事，尽力而为，因为我们不知道人们会因为哪一件具体的事评价我们的人生。

期望值有两种方法：1. 最笨的，也就是把每种情况（就是拿到0，1，2，3，4，5，6，7个指点球）都算出来[超几何分布计算公式：p(x=r)=(Cm r*CN-M n-r)/CNn，"C"是组合数，m与r分别是下标与上标，这里不好打出来]。然后写出概率分布列，将每一纵行的P(x=r)与r相乘，所求结果相加，即可得出期望值。2. 还有一种就是简单的公式法，E(X)=(n*M)/N [其中x是指定样品数，n为样品容量，M为指定样品总数，N为总体中的个体总数]，可以直接求出均值。方差也有两种算法（都是公式法）：1.这里设期望值为a,那么方差V(X)=（X1-a）^2*P1+(x2-a)^2*P2+...+(Xn-a)*Pn。2.另一种是V(X)=X1^2*P1+X2^2*P2+...Xn^2*Pn-a^2 [这里同样设a为期望值]

先推荐两本国内的 清华严蔚敏的《数据结构》 电子工业出版社王晓东《计算机算法设计与分析》 这两本书是我入门时候看的，比较经典 国外的这方面的书很多，比较好的有 《数据结构与算法分析——C语言描述（原书第2版）》 作者：（美）MARK ALLEN WEISS 译者：冯舜玺 机械工业出版社 这书我看的是第二版，好像现在已经有第三版了，十分经典 还有 数据结构与算法分析（C++版）（第二版） 作者：（美）CLIFFORD A.SHAFFER 译者：张铭等 电子工业出版社bbs.kaoyan.com，这里面有，自己去淘咯

　　一、引言　　吉林省各地自然、经济、社会条件各有差异，对农业经济的影响很大。为了稳定提高粮食综合生产能力，促进农业经济结构进一步优化。就需要准确地对省内各市县农业经济类型进行划分，以期做到合理的资源优化配置。本文采用一种改进的k-均值聚类分析技术对所采集的吉林省各县市农业生产的相关数据进行分析，目的是对吉林省各地农业经济类型进行划分，揭示各地区农业生产的特点和优势，为加快全省农业经济发展提供依据。 　　二、改进的聚类算法基本原理 　　改进的聚类算法的基本思想是：首先对数据集合进行系统聚类分析，得到聚类树及相应的聚类中心矩阵；接着从聚类树中查找较早形成的大类，并计算其聚类中心，这样我们就得到了较好的聚类数k及比较具有代表性的初试聚类中心集合；最后通过k-均值算法进行聚类分析。 　　虽然此改进算法需要我们人为的设定条件，但是这些条件都是在进行系统聚类分析之后的数据基础上得来的，比经典的k-均值算法的直接判断聚类数和随机抽取初始聚类中心要具有明显的优势。根据本文待挖掘的数据量和系统聚类的结果，初始条件设定如下：被判定为较早形成的大类聚类，其包含的数据对象应大于4，与下一次合并的聚类间距越小越好，且应小于所有聚类过程中的聚类间距均值。 　　三、改进的聚类算法在吉林农业经济类型划分中的应用 　　（一）分类指标的选择 　　农业经济系统是一个多因素、多层次、结构复杂的系统，要正确地划分农业经济类型，首先必须选择一套能全面反映当前农业经济状况的指标体系。为此我们根据吉林农业的实际情况，选择对农业经济发展起主导作用的因子作为聚类指标，通过实地调查和对统计资料的综合分析，选定以下10个指标：X1 ，年平均降水量；X2 ，年平均温度；X3 ，农业人口；X4 ，每公顷粮食产量；X5 ，农业机械总动力；X6 ，粮食面积占耕地面积比例；X7 ，林业产值占农业总产值比例；X8 ，牧业产值占农业总产值比例；X9，渔业产值占农业总产值比例；X10 ，人均收入。 　　（二）数据准备 　　根据以上10项指标，我们通过查阅2010年《吉林省统计年鉴》可以得到吉林省各地区农业经济各项指标的原始数据，如表1所示。 　　数据来源：根据2010年《吉林省统计年鉴》整理。 　　（三）数据挖掘结果 　　首先对以上数据进行标准化转换，之后采用系统聚类分析法得到聚类树，分析聚类树及聚类间距我们可以得到初始聚类数为k=5。之后，本文进行k=5的k-均值聚类分析，得到聚类成员表如下： 　　（四）结果分析 　　方差分析表的结果表明，分类后各变量在不同类别之间的差异都是显著的（p值基本都小于0.05，接近于零），表示把20个县市地区分成5类是比较合理的。 　　第一类，梨树、伊通、公主岭、双辽、东丰、长岭6个县市。这些县市年平均温度较高，降水较少，粮食面积占耕地面积比例都比较小，牧业相对于林业、渔业有明显的优势，其人居收入相对较高。这类地区应该对其农业产业结构进行适当调整，使农林牧副业各产业协调发展。 　　第二类，桦甸、通化、辉南3个县市。这类县市农、林、牧渔各业都有一定发展，各项经济指标居于全省中上等水平，其振兴经济最好的途径就是各业协调发展，根据各县实际情况，积极引进科学技术和优良品种，走农业产业化发展之路。 　　第三类，农安、榆树、德惠、扶余4个县市。这类县市虽然粮食面积占耕地面积比例很高，但是由于自然条件相对较差，降水贫乏，从而制约了该类地区的农业经济发展。对此，应该采取兴修水利的措施来缓解雨水不足的现状。此外，应在稳定粮食产量的基础上积极改善生态环境，发展多种经营，稳步发展其农业经济。 　　第四类，蛟河市、梅河口市。这两个市的农业经济状况是所有县市中最好的，该地区雨水充足、粮食面积占耕地面积比例较高、畜牧业发展相对滞后、林业和渔业发展较其他地区有明显优势且人均收入明显高于其他各地区。因此，该类地区应注意保持其现有的农业产业结构同时兼顾畜牧业的发展，做到以优势产业拉动劣势产业的协调发展。 　　第五类，九台、永吉、舒兰、磐石、东辽5个县市。这类县市自然条件适宜、粮食面积占耕地面积比例很高，林业、畜牧业和渔业协调发展较好。该地区应充分合理利用自然条件优势，实行以发展粮食生产为主，兼顾其他各业的农业发展思路。 　　四、结论 　　将数据挖掘技术应用到农业经济类型的划分中，极大地改善了以往的划分方式。本文通过聚类分析方式对吉林省农业经济数据进行了数据挖掘，并提出了一种聚类分析的改进方法，使其更好地应用于农业经济类型的分类中，使得对农业经济类型的划分更客观、可靠。 　　参考文献： 　　①何晓群．多元统计分析［M］．北京：中国人民大学出版社，2008 　　②汤效琴，戴如源．数据挖掘中聚类分析的技术方法［J］．微计算机信息，2003（19） 　　③张红云等．数据挖掘中聚类算法比较研究［J］．计算机应用与软件，2003（2） 　　④曾志雄．一种有效的基于划分和层次的混合聚类算法［J］．计算机应用，2007（7）：1692—1695 　　（姚洁，1972年生，吉林省吉林市人，东北电力大学经济管理学院教授。研究方向：技术经济理论与实务。姜域，1988年生，新疆阿勒泰人，东北电力大学硕士研究生。研究方向：科技与经济协调发展）

学校应该还是能申 但一流的估计不行

你自己把所有课程成绩加起来算一个算术平均分就好了，100分满分，大约多少平均分就好。高于75分，可以考虑申请德国留学。申请本科或者硕士，都跟aps审核部帮你计算的成绩没有什么关系。

首先你估计要过一下aps然后证书上会有平均分我估计你在1.5到1.7。话说1分最好5分是没过再然后斯图加特不是巴伐利亚的人家是巴登福登堡 巴伐利亚是慕尼黑

德国一般是按照巴伐利亚算法来换算外国学生的分数，基本不参考GPA算法。1分最高，5分最低，4分等于及格。一门课61对整体是有一定影响，但是只要之后好好学，把课程分数提高，平均下来影响不大，最终平均分能保持在80以上就好，当然越高对申请越有利，尤其是要申请名校。专业课程，专业相关的基础课程和选修课程都比较重要。

巴伐利亚算法只是一种计算方法，跟计算什么课程没有关系。审核部的计算是所有课程都要计算的。德国大学计算的时候就按需计算了。

其实计算机程序底层核心就是各种数学算法，剩下就是怎么用代码去实现数学，世界上有名的计算机程序大牛几乎都跟数学权威方面的专家有关。 从另一个角度回答，因为就算看懂百分百，也很难超越另外的百分之十 很多程序员没读过算法导论 其实不管是对于在校生来说还是已经工作的程序员，一般很少都会接触算法。 学生的话也只有计算机相关专业的开设了数据结构和算法相关课程的才需要用到，但如果只是对付期末考试的话也没啥难度。 但是如果在大学期间接触到算法竞赛就不一样了，需要花费比较多的精力。 的确在工资上任何公司都是10%的算法大佬拿的工资比其他90%的业务开发程序员或者其他的程序员都要高，不过就凭只懂《算法导论》这本书的话还是不太行的，算法离不开业务的。就算超越也是超越那10%的算法工程师里的90%，如果能达到这个境界别说BAT了，微软谷歌都是可以考虑的。 说这个话在我看来他可能是想卖课，卖完再慢慢告诉你，“学到90％也没有那么容易”，或者“在刷我这套题这件事上超越90％的程序员 并不等于收入上超越90％的程序员”。 你多去拼多多参加几个活动，在文字 游戏 和预期管理上你应该就懂了；要是还不懂，大概你也不是那么适合做这一行以及算法导论。 公式：弄懂+一本名著+百分比+超越+百分比+你的群体。 例句： 弄懂sicp的67.9%，你就超越了95%的程序员。 弄懂本草纲目的72%，你就超越了93.7%的中医。 弄懂冰箱说明书的83%，你就超越了99.9%的冰箱使用者（这也许是最真实的，虽然冰箱说明书不是名著……） 至于为什么这么说……个人觉得就是对xx东西的一种崇拜，很大程度上是人云亦云。 算法导论是本不会动的书，不同人读效果不一样的。不要神化某一本书，参差多态乃幸福本源。不看算法导论你也可以会算法，你也可以会数据结构，你也可以进大厂。没有算法导论的时候也依然有研究算法的科学家。你能通过他学会知识很好，但你觉得它晦涩，搞不懂，没有c的代码让你学的不舒服，那就不看他。 人生中见书，书中见人生。读书有时候不一定是为了学东西，可能更多的是一种享受。就像你没学看过csapp之前，通过各种课程，学了零零碎碎的知识。忽然有一天你看了csapp，你觉得好过瘾啊，好爽啊。你觉得你学习的第一天就看csapp能有这种效果吗？ 好书不会变少只会变多，更何况帮到你的也未必需要是好书。也许一本书只是很普通的书，不严谨，还都是大白话，但未必就帮不到你。 学东西莫要搞崇拜。很多程序员学习的时候都不是通过算法导论这本书学的，可他们依然很杰出。 程序员来回答一下： 1.《算法导论》这本书理论来说90%程序员也没弄懂，所以你弄懂了就超过了90%。 2.其实程序员是一个大的行业，IT也是一个大的行业，门外人看着都是一群写程序的，修电脑的，更有人认为是装电脑系统的，你被别人交过去装过系统吗？ 3.程序员架构上来说，嵌入式 协议栈 应用 网络 服务器 工具 系统 等等等！ 4.有一些行业是不需要看算法导论的，更有一些转行过来的，应该更不太了解算法导论。 这本书在美国的大学被称为clrs, 是标准的本科高年级和研究生入门的算法课课本。优点是比较全面的讲解了常用和基本的算法，习题质量不错。问题是动态规划讲的不好，篇幅原因一些近代的算法没有概括。总的来说是本不错的算法入门教科书。 算法是计算机科学的核心。计算理论偏数学，编译原理和操作系统偏硬件，真正计算机科学的核心就是算法。无论做研究还是搞工程，都是必不可少的。 程序是给人看的，不是给机器。写给机器的程序谁都可以写出来，但不是每个程序员都能写出别人看懂的东西 程序是什么，程序就是数据结构和算法，弄懂了超90%的程序员不是很正常嘛 看懂2%就超过了80%，没必要看那么多 因为这本书翻译的很枯燥、也很理解，这种情况下你还理解了90%，说明你有耐心，有恒心，耐得住寂寞。我相信不只是做程序员，做其它行业也会很优秀。

近日，融合了华为自动驾驶技术的北汽吉虎电动汽车着火了！所有人都感到震惊：为什么家用汽车以前基本上都是L3（在高速道路上自动驾驶），为什么现在又升级为L4自动驾驶仪？自动驾驶仪分类标准必须知道，特斯拉的自动驾驶仪具有丰富的经验。经过几年的发展，它仅达到了目前的L3-L4水平。关键在于车辆的感知技术是不同的。特斯拉使用纯视觉识别（相机）解决方案，而华为则使用激光雷达技术。这里提到的激光雷达不是那种明亮而又盲目的激光，人眼是看不见的。这是扫地机器人用来探索道路的激光（LiDAR）。无非是看得更清楚，更远的汽车。华为和特斯拉的自动驾驶是两条不同的技术路线。特斯拉主要依靠视觉识别（即相机），因此存在以下问题：1.难以捕获准确的三维信息。相机提取的信息几乎是二维平面，尤其是稍远的物体，很难与背景区分开。它们都是基于经验来补充深度信息，然后在想象中拼凑成三维三维形状。例如，在美国，有一辆卡车高速翻滚并躺下，因为车身是蓝色和白色，与天空背景混合在一起，无法被识别。特斯拉没有放慢脚步，直奔它，车主死了。 2.较长的人工智能学习周期视觉人工智能识别实际上就像在教育孩子，不断地教授人工智能来识别新场景，然后在识别后转变为新场景。它可能涵盖了大多数场景，但是总会有一些无法识别的意外情况。识别水平的提高取决于向AI提供大量数据，以及不断的训练和改进。例如，如果您将卡车的数百张照片喂给AI，它会记住这是卡车，其长度，宽度和高度通常约为此大小。但是，在极少数情况下，卡车运载的某些管道超出了限制2米，这取决于它是否了解了这种情况或是否可以自行推理。换句话说，既然人类可以通过视觉和声音辅助来实现驾驶功能，那么为什么不能通过摄像头实现自动驾驶呢？当然，您只需听一听，如果您真的相信它，那就太天真了。特斯拉不想使用它，但负担不起。 Velodyne在国外生产的64线机械激光雷达的价格为数万人民币。业内人士估计，4000元起价是一个门槛，而2000元起价是大规模普及的时候。马斯克估计，在3-5年内，激光雷达将无法达到大规模生产所需的价格。这条路线浪费时间。不，~~~~~~~，中国又把黑技术变成了白菜的价格。华为生产的96线固态激光雷达比Velodyne先进，价格超过2,000元人民币。你买不到两千元，你不会受苦，你不能上当！很抱歉谈论电子产品的供应链。这里的每个人都不能与中国抗争。汽车将是未来的一大电子产品。当然，华为在使用激光雷达时也有自己的困难。采取视觉路线，对芯片的依赖性将增加，因为局部计算将非常大。使用激光雷达，大大减少了本地机载计算处理，并且不需要高端的7纳米芯片。它也可以被视为用一块石头杀死两只鸟。它不仅避免了美国对芯片的控制，而且还超过了特斯拉在弯道上的自动驾驶水平。目前，激光雷达应优于纯视觉识别。但是，两者在将来并不相互排斥。未来的发展方向很可能会同时使用，相互融合和相辅相成。比亚迪，吉利，蔚来等国内自主品牌制造商在过去的几年中取得了长足的进步。使用Lidar后，它们应该更加强大。在未来的5-10年中，人们认为在移动电视上自有品牌超越外国品牌的故事很可能会再次在智能汽车中上演。

根据以下公式你可以算一下： 男性:身高(cm)-105=标准体重(kg) 女性:身高(cm)-100=标准体重(kg) 以上两种计算方法，基本已被广泛采用。 另外，最近军事科学院还推出一计算中国人理想体重的方法： 北方人理想体重=(身高cm-150)×0.6+50(kg) 南方人理想体重=(身高cm-150)×0.6+48(kg) 这一计算方法，似乎比较适合南北地区中国人。 儿童标准体重的计算，简便的方法是： 1～6个月：出生体重(kg)+月龄×0.6=标准体重(kg) 7～12个月：出生体重(kg)+月龄×0.5=标准体重(kg) 1岁以上：8+年龄×2=标准体重(kg) 但是，由于人的体重与许多因素有关，不同人体之间有差异，一天不同的时间内也会有一定变化，加之所处地理位置(如地心引力的原因)、季节、气候、自身情况的不同，对体重也有一定影响，因而很难完全符合标准体重。也就是说，难以用一个恒定值来表示，而应当是一个数值范围，我们把这个数值范围称之为正常值，一般在标准体重±10%以内的范围。超过这一范围，就可称之为异常体重。

参考地址：http://baike.baidu.com/view/348542.htm里边那个名称就是广义的。关系R和关系S的元数分别是3和4,关系T是R与S的广义笛卡儿积,即T=R×S,则关系T的元数是（）关系是乘(只是一种定义),但是元数用加,这就是

（以下描述，均不是学术用语，仅供大家快乐的阅读） 　　上一篇记录了蝴蝶算法（Butterfly Algorithm），这一篇接着记录帝王蝶算法（Monarch butterfly optimization）。 　　介绍之前我们先看看帝王蝶的百科，了解其特性，这将有利于我们对算法的理解和记忆。 　　帝王蝶算法（Monarch butterfly optimization）是根据帝王蝶的迁徙行为提出的优化算法。帝王蝶算法也是于2015年提出，相关的论文也比较多了（这两个蝴蝶算法都有这么多人关注吗？）。其流程相对蝴蝶算法来说有点复杂，不过其论文对算法描述非常的清晰，大家可以去阅读原文。 　　帝王蝶算法中，每只蝴蝶的位置代表一个可行解，蝴蝶群体将会被分布在两个大陆上，这两块大陆上的帝王蝶分别有不同的行为：1.迁徙，2适应环境。帝王蝶算法组合了这两种行为来搜索解空间中的最优位置。 帝王蝶算法中每只蝴蝶的为 ，该位置的优劣由其适应度函数F(X)计算得出。 帝王蝶群体分布在两块大陆上，分别是land1和land2上。对于一只随机帝王蝶来说，它位于land1上的概率为p,位于land2上的概率为1-p。以此可以将总群分为2个群体，论文中p取值维5/12。 　　Land1上的群体的行为为迁徙，而land2上的群体的行为为适应环境。 位于land1上的群体的行为为迁徙，这部分个体在种群中的比例为p。其计算公式如下： 不同与land1上的群体，land2上的群体的行为为适应环境，其计算公式如下： 从2.2和2.3可看出，帝王蝶算法的流程也非常的简单，过程中也只有两个公式。 　　可以看出，帝王蝶算法的流程和蝴蝶算法的流程几乎一模一样（废话，流程图直接copy的，当然一样），两个算法的个体都是拥有两种行为，蝴蝶算法的行为比较整体，宏观操作，新个体由2-3个个体得出，而帝王蝶算法的行为比较零散，微观操作，每一维来自一个个体。两个算法也都使用了levy飞行，考虑到两个算法竟然还是同一年的，莫非，难道…… 　　不过从细节来看，两个算法差异还是比较大的，不过两个算法的性能也都算是中规中矩的那种，没有特别突出的特点。 适应度函数 。 实验一 ： 从图像中可以看出，帝王蝶算法收敛的非常之快，几乎在10代以内就聚集在了目标解附近。从结果中也可以看出，10次结果中仅有一次较差，其它结果也都很接近0。效果比较好，我总觉得参数的设置不太对称，改成对称试试结果。 实验二 ：修改参数p=0.5,peri = 1,BAR=0.5,即迁徙操作两个种群各占一半维度，适应环境操作最优个体站一半维度，1/4进行levy飞行。 从结果可以看出，将参数改为对称后效果差了不少。图像我选取一副较差的图像，从图像可以看出在最后，种群收敛到了目标解外的一点。收敛的过程很像遗传算法和差分进化算法，个体的运动轨迹在一个类似十字架的图案上。但是这个适应度函数非常简单，不存在局部最优解，问题应该出在步长上。整个算法只有levy飞行那一步会产生新的位置，其他步骤都是现有位置的组合。 下面将最大步长改大试试。 实验三 ：在实验二的基础上，将S_max改为100。 结果比实验二好了不少，但精度有所下降，但是比不上实验一。最大步长设的太大会影响精度，设得太小又会让种群提前收敛。实验三中最大步长为100，最大迭代次数为50，则由最大步长影响的精度为100/(50*50)=0.04,这与实验结果相差不太多。权衡利弊，S_max的取值还是大一点的好，否则，种群未在正解附近收敛得到的结果会很差，结果会很不稳定。 实验四 ： 在实验一的基础上将S_max修改为100，与实验三比较原文其他参数是否合适。 从结果可以看出，这次的结果要好于实验三的结果，这说明原文中给出的这一系列不对称的参数效果还是好于实验二实验三中的对称参数。图像与实验三的图像类似，步长改大之后个体很容易飞出边界，然后由越界的处理方法使其留在边界上，所以在算法开始后不久就可以看到群体都停留在了边界上，不过问题不大，最终还是会收敛与正解附近。 　　与实验一相比，实验四的结果差了不少，这是因为测试函数比较简单，当选用较为复杂的测试函数后，较大的步长能够提高算法的全局搜索能力，让算法的结果更加稳定。 帝王蝶算法是根据帝王蝶的迁徙行为提出的算法。位于两块大陆上的帝王蝶群体有着不同的行为，迁徙行为类似于进化算法的杂交操作，适应环境行为类似于进化算法的变异操作，不过其变异位置在当前最优个体附近。算法中的levy飞行是其变异操作的具体实现，不过由于受最大步长的影响，levy飞行的作用并不明显。帝王蝶的最大飞行步长对结果的影响较为明显，步长较小时算法的全局搜索能力较差，局部搜索能力较强，精度较高，反之，全局搜索能力较强，局部搜索能力较差，精度较低但是更加稳定。 　　帝王蝶算法的参数非常奇特，按论文中所说是根据蝴蝶在各地活动的月数而设定的。虽然不是最佳参数，但也优于均匀对称的参数。有兴趣的同学可以试试怎么设置能让算法的性能达到最佳。 　　接连两篇笔记记录了都是蝴蝶算法，它们的总体流程结构相差不大，一个是宏观行为，个体之间互动，一个是微观行为，维度之间互动。这两个蝴蝶算法的性能也相差不多，中规中矩，没有太亮眼的地方，而且都用了levy飞行来提供跳出局部最优的能力。不过levy作为非常规武器，不应该在原始算法中给出，其操作与levy飞行不搭且没有提供相应的能力（可能我看到的不是原始论文）。 参考文献 Monarch butterfly optimization[J]. Neural Computing and Applications, 2015, 31:1995-2014. 提取码：fg2m Wang G G , Zhao X , Deb S . A Novel Monarch Butterfly Optimization with Greedy Strategy and Self-adaptive Crossover Operator[C]// 2015 2nd Intl. Conference on Soft Computing & Machine Intelligence (ISCMI 2015). IEEE, 2015. 提取码：9246 以下指标纯属个人yy,仅供参考 目录 上一篇 优化算法笔记（二十三）蝴蝶算法 下一篇 优化算法笔记（二十五）飞蛾扑火算法

1、算法的时间复杂度的意思是：2、3、算法的时间复杂度是衡量一个算法效率的基本方法。在阅读其他算法教程书的时候，对于算法的时间复杂度的讲解不免有些生涩，难以理解。进而无法在实际应用中很好的对算法进行衡量。4、5、《大话数据结构》一书在一开始也针对算法的时间复杂度进行了说明。这里的讲解就非常明确，言简意赅，很容易理解。下面通过《大话数据结构》阅读笔记的方式，通过原因该书的一些简单的例子和说明来解释一下算法的时间复杂度和它的计算方法。6、7、更多关于算法的时间复杂度是，进入：https://m.abcgonglue.com/ask/27526f1616081185.html?zd查看更多内容

C语言的基本语法你只要掌握了数据结构都不是问题数据结构就是 数据的组织方式 或者说 是一种更便捷的让程序更高效的方法。这里面用到的都是C语言的基础知识。就像你做饭 一个辣椒可以炒素菜、可以炒荤菜、也可以炸成辣椒油……同样一个东西 根据自己目的的不同 选择一个最高效的方法 就是数据结构与算法的目的.书上的数据结构与算法 只是给你一些实际应用中的列子和一些基本方法，现实中做程序还需要你自己根据自己的需要去组合去研究更好的算法……

不对 算法的各步骤中,前后顺序一般不能交换,否则会产生不一样的效果 。算法学习顺序：首先得把数据结构与算法学完，当然，在学习数据结构与算法时，不是直接去刷题的，得先去看书，学习理论知识。如果你是刚学编程不久，想去学习数据结构与算法的话，我推荐一本书籍《大话数据结构》，这是一本适合大一新生未接触很多编程的同学，其用易解的方式去让我们理解数据结构等相关概念，及一些代码的用意，是一本非常适合新手入门数据结构与算法的同学啊。当你在算法上有足够的实力的话，可以在去学习《算法导论》这一本书籍，这是一本外籍的专业书，如果你英语够好，建议你去看英文版的，不过，实在勉强的话还是有中文版的，这本书里包含对算法本质，时间复杂度等分析，是一本非常好的书籍(算法)，当然，里面并不是为将整个代码直接给出，而是，会给出相应的伪代码，其语言也不是C语言或者是C++，当然，里面涉及到的特定语言会给出相应解释，这是一本让你更为深刻的去了解算法的书籍。等你能够啃完《算法导论》这一本书籍后，那么你的实力已经达到了一定的水平，这个时候，你可以去看《计算机程序设计艺术》，认真去啃完！！！当然的话，还有一本书《数据结构与算法分析》(C语言描述）这一本就非常适合学过C语言的同学去啃，这本书的质量及水平是非常之高的。学了还要去应用。这时候，你就要去努力刷题，可以在leetcode或者在一些书籍的题库中刷等等。对于我自己来说的话，有时在刷题时，就算看源代码自己也理解不了，这种情况自己非常的无赖，但是，我就努力在网上查教程，查书籍，把一个大问题分治，一个一个的解决，最后，等自己能够理解，并打出来时，自己就体会到了刷题的乐趣。

《数据结构与算法分析—C++语言描述》有对应全书的各种代码，学习时可以先自己实现，然后各种痛苦地找bug，然后痛苦上一段时间再根据代码修改程序，可以产生深刻的映像，非常的管用，我学的是java，主攻也是java，但是就是这么一本数据结构的书，让我现在都没有忘记c++程序要怎么编，那几种结构怎么用，虽然编不了太专业的，不过不涉及复杂运用的程序都没有什么问题~

人工智能的方法，先定义个目标函数，用剪枝策略搜索

http://www.cublog.cn/u/8780/showart.php?id=163291 在一个3×3的九宫中有1－8这8个数及一个空格随机的摆放在其中的格子里，如图1－1所示。现在要求实现这个问题：将其调整为如图1－1右图所示的形式。调整的规则是：每次只能将与空格（上、下、或左、右）相邻的一个数字平移到空格中。试编程实现这一问题的求解。（图1－1）二、题目分析： 这是人工智能中的经典难题之一，问题是在3×3方格棋盘中，放8格数，剩下的没有放到的为空，每次移动只能是和相邻的空格交换数。程序自动产生问题的初始状态，通过一系列交换动作将其转换成目标排列（如下图1－2到图1－3的转换）。（图1－2） （图1－3） 该问题中，程序产生的随机排列转换成目标共有两种可能，而且这两种不可能同时成立，也就是奇数排列和偶数排列。可以把一个随机排列的数组从左到右从上到下用一个一维数组表示，如上图1－2我们就可以表示成｛8，7，1，5，2，6，3，4，0｝其中0代表空格。在这个数组中我们首先计算它能够重排列出来的结果，公式就是：∑（F（X））＝Y，其中F（X）是一个数前面比这个数小的数的个数,Y为奇数和偶数时各有一种解法。（八数码问题是否有解的判定 ）上面的数组可以解出它的结果。F（8）＝0；F（7）＝0；F（1）＝0；F（5）＝1；F（2）＝1；F（6）＝3；F（3）＝2；F（4）＝3；Y＝0＋0＋0＋1＋1＋3＋2＋3＝10 Y＝10是偶数，所以其重排列就是如图1－3的结果，如果加起来的结果是奇数重排的结果就是如图1－1最右边的排法。三、算法分析 求解方法就是交换空格（0）位置，直至到达目标位置为止。图形表示就是：（图3－1） 要想得到最优的就需要使用广度优先搜索，九宫的所以排列有9！种，也就是362880种排法，数据量是非常大的，使用广度搜索，需要记住每一个结点的排列形式，要是用数组记录的话会占用很多的内存，可以把数据进行适当的压缩。使用DWORD形式保存，压缩形式是每个数字用3位表示，这样就是3×9＝27个字节，由于8的二进制表示形式1000，不能用3位表示，使用了一个小技巧就是将8表示为000，然后用多出来的5个字表示8所在的位置，就可以用DWORD表示了。用移位和或操作将数据逐个移入，比乘法速度要快点。定义了几个结果来存储遍历到了结果和搜索完成后保存最优路径。类结构如下：class CNineGird{public:struct PlaceList {DWORD Place;PlaceList* Left;PlaceList* Right; };struct Scanbuf{DWORD Place;int ScanID;};struct PathList{unsigned char Path[9];};private:PlaceList *m_pPlaceList;Scanbuf *m_pScanbuf;RECT m_rResetButton;RECT m_rAutoButton;public:int m_iPathsize;clock_t m_iTime;UINT m_iStepCount;unsigned char m_iTargetChess[9];unsigned char m_iChess[9];HWND m_hClientWin;PathList *m_pPathList;bool m_bAutoRun;private:inline bool AddTree(DWORD place , PlaceList*& parent);void FreeTree(PlaceList*& parent);inline void ArrayToDword(unsigned char *array , DWORD & data);inline void DwordToArray(DWORD data , unsigned char *array);inline bool MoveChess(unsigned char *array , int way);bool EstimateUncoil(unsigned char *array);void GetPath(UINT depth);public:void MoveChess(int way);bool ComputeFeel();void ActiveShaw(HWND hView);void DrawGird(HDC hDC , RECT clientrect);void DrawChess(HDC hDC , RECT clientrect);void Reset();void OnButton(POINT pnt , HWND hView);public:CNineGird();~CNineGird();}; 计算随机随机数组使用了vector模板用random_shuffle（，）函数来打乱数组数据，并计算目标结果是什么。代码：void CNineGird::Reset(){if(m_bAutoRun) return;vector vs;int i;for (i = 1 ; i < 9 ; i ++)vs.push_back(i);vs.push_back(0);random_shuffle(vs.begin(), vs.end()); random_shuffle(vs.begin(), vs.end()); for ( i = 0 ; i < 9 ; i ++){m_iChess[i] = vs[i];}if (!EstimateUncoil(m_iChess)){unsigned char array[9] = {1,2,3,8,0,4,7,6,5};memcpy(m_iTargetChess , array , 9);}else{unsigned char array[9] = {1,2,3,4,5,6,7,8,0};memcpy(m_iTargetChess , array , 9);}m_iStepCount = 0;}数据压缩函数实现：inline void CNineGird::ArrayToDword(unsigned char *array , DWORD& data){unsigned char night = 0;for ( int i = 0 ; i < 9 ; i ++){if (array[i] == 8){night = (unsigned char)i;break;}}array[night] = 0;data = 0;data = (DWORD)((DWORD)array[0] << 29 | (DWORD)array[1] << 26 | (DWORD)array[2] << 23 | (DWORD)array[3] << 20 | (DWORD)array[4] << 17 | (DWORD)array[5] << 14 | (DWORD)array[6] << 11 | (DWORD)array[7] << 8 | (DWORD)array[8] << 5 | night);array[night] = 8;}解压缩时跟压缩正好相反，解压代码：inline void CNineGird::DwordToArray(DWORD data , unsigned char *array){unsigned char chtem;for ( int i = 0 ; i < 9 ; i ++){chtem = (unsigned char)(data >> (32 - (i + 1) * 3) & 0x00000007);array[i] = chtem;}chtem = (unsigned char)(data & 0x0000001F);array[chtem] = 8;} 由于可扩展的数据量非常的大，加上在保存的时候使用的是DWORD类型，将每一步数据都记录在一个排序二叉树中，按从小到大从左到有的排列，搜索的时候跟每次搜索将近万次的形式比较快几乎是N次方倍，把几个在循环中用到的函数声明为内联函数，并在插入的时候同时搜索插入的数据会不会在树中有重复来加快总体速度。二叉树插入代码：inline bool CNineGird::AddTree(DWORD place , PlaceList*& parent){if (parent == NULL){parent = new PlaceList();parent->Left = parent->Right = NULL;parent->Place = place;return true;}if (parent->Place == place)return false;if (parent->Place > place){return AddTree(place , parent->Right);}return AddTree(place , parent->Left);}计算结果是奇数排列还是偶数排列的代码：bool CNineGird::EstimateUncoil(unsigned char *array){int sun = 0;for ( int i = 0 ; i < 8 ; i ++){for ( int j = 0 ; j < 9 ; j ++){if (array[j] != 0){if (array[j] == i +1 )break;if (array[j] < i + 1)sun++;}}}if (sun % 2 == 0)return true;elsereturn false;} 移动到空格位的代码比较简单，只要计算是否会移动到框外面就可以了，并在移动的时候顺便计算一下是不是已经是目标结果，这是用来给用户手工移动是给与提示用的，代码：inline bool CNineGird::MoveChess(unsigned char *array , int way){int zero , chang;bool moveok = false;for ( zero = 0 ; zero < 9 ; zero ++){if (array[zero] == 0)break;}POINT pnt;pnt.x = zero % 3;pnt.y = int(zero / 3);switch(way){case 0 : //upif (pnt.y + 1 < 3){chang = (pnt.y + 1) * 3 + pnt.x ;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 1 : //downif (pnt.y - 1 > -1){chang = (pnt.y - 1) * 3 + pnt.x ;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 2 : //leftif (pnt.x + 1 < 3){chang = pnt.y * 3 + pnt.x + 1;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 3 : //rightif (pnt.x - 1 > -1){chang = pnt.y * 3 + pnt.x - 1;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;}if (moveok && !m_bAutoRun){m_iStepCount ++ ;DWORD temp1 ,temp2;ArrayToDword(array , temp1);ArrayToDword(m_iTargetChess , temp2);if (temp1 == temp2){MessageBox(NULL , "你真聪明这么快就搞定了!" , "^_^" , 0); }}return moveok;} 在进行广度搜索时候，将父结点所在的数组索引记录在子结点中了，所以得到目标排列的时候，只要从子结点逆向搜索就可以得到最优搜索路径了。用变量m_iPathsize来记录总步数，具体函数代码：void CNineGird::GetPath(UINT depth){int now = 0 , maxpos = 100 ;UINT parentid;if (m_pPathList != NULL){delete[] m_pPathList;}m_pPathList = new PathList[maxpos];parentid = m_pScanbuf[depth].ScanID;DwordToArray(m_pScanbuf[depth].Place , m_pPathList[++now].Path);while(parentid != -1){if (now == maxpos){maxpos += 10;PathList * temlist = new PathList[maxpos];memcpy(temlist , m_pPathList , sizeof(PathList) * (maxpos - 10));delete[] m_pPathList;m_pPathList = temlist;}DwordToArray(m_pScanbuf[parentid].Place , m_pPathList[++now].Path);parentid = m_pScanbuf[parentid].ScanID;}m_iPathsize = now;} 动态排列的演示函数最简单了，为了让主窗体有及时刷新的机会，启动了一个线程在需要主窗体刷新的时候，用Slee（UINT）函数来暂停一下线程就可以了。代码：unsigned __stdcall MoveChessThread(LPVOID pParam){CNineGird * pGird = (CNineGird *)pParam;RECT rect;pGird->m_iStepCount = 0;::GetClientRect(pGird->m_hClientWin , &rect);for ( int i = pGird->m_iPathsize ; i > 0 ; i --){memcpy(pGird->m_iChess , pGird->m_pPathList[i].Path , 9);pGird->m_iStepCount ++;InvalidateRect( pGird->m_hClientWin , &rect , false);Sleep(300);}char msg[100];sprintf(msg , "^_^ ! 搞定了! 计算步骤用时%d毫秒" , pGird->m_iTime);MessageBox(NULL , msg , "~_~" , 0);pGird->m_bAutoRun = false;return 0L;} 最后介绍一下搜索函数的原理，首先得到源数组，将其转换成DWORD型，与目标比较，如果相同完成，不同就交换一下数据和空格位置，加入二叉树，搜索下一个结果，直到没有步可走了，在搜索刚刚搜索到的位置的子位置，这样直到找到目标结果为止，函数：bool CNineGird::ComputeFeel(){unsigned char *array = m_iChess;UINT i;const int MAXSIZE = 362880;unsigned char temparray[9];DWORD target , fountain , parent , parentID = 0 , child = 1;ArrayToDword(m_iTargetChess , target);ArrayToDword(array , fountain);if (fountain == target){return false;}if (m_pScanbuf != NULL){delete[] m_pScanbuf;}m_pScanbuf = new Scanbuf[MAXSIZE];AddTree(fountain ,m_pPlaceList);m_pScanbuf[ 0 ].Place = fountain;m_pScanbuf[ 0 ].ScanID = -1;clock_t tim = clock();while(parentID < MAXSIZE && child < MAXSIZE){parent = m_pScanbuf[parentID].Place;for ( i = 0 ; i < 4 ; i ++) // 0 :UP , 1:Down ,2:Left,3:Right{DwordToArray(parent , temparray);if (MoveChess(temparray,i)) //是否移动成功{ArrayToDword(temparray , fountain);if (AddTree(fountain, m_pPlaceList)) //加入搜索数{m_pScanbuf[ child ].Place = fountain;m_pScanbuf[ child ].ScanID = parentID;if (fountain == target) //是否找到结果{m_iTime = clock() - tim;GetPath(child);//计算路径FreeTree(m_pPlaceList);delete[] m_pScanbuf;m_pScanbuf = NULL;return true;}child ++;}}} // for iparentID++;}m_iTime = clock() - tim;FreeTree(m_pPlaceList);delete[] m_pScanbuf;m_pScanbuf = NULL;return false;}重要函数的介绍结束;下面是程序的运行结果和运算结果：

#pragma warning(disable:4786) #include <algorithm> #include <cstdio> #include <set> #include <utility> #include <ctime> #include <cassert> #include <cstring> #include <iostream>using namespace std;/*item记录搜索空间中一个结点 state 记录用整数形式表示的8数码格局 blank 记录当前空格位置，主要用于程序优化，扩展时可不必在寻找空格位置 g, h 对应g(n), h(n) pre 记录当前结点由哪个结点扩展而来 */struct item { int state; int blank; int g; int h; int pre; };const int MAXSTEPS = 100000; const int MAXCHAR = 100; char buf[MAXCHAR][MAXCHAR]; //open表 item open[MAXSTEPS]; //vector<item> open;int steps = 0;//closed表，已查询状态只要知道该状态以及它由哪个结点扩展而来即可，用于输出路径 //每次只需得到对应f值最小的待扩展结点，用堆实现提高效率pair<int, int> closed[MAXSTEPS];//读入，将8数码矩阵格局转换为整数表示 bool read(pair<int,int> &state) { if (!gets(buf[0])) return false; if (!gets(buf[1])) return false; if (!gets(buf[2])) return false; //cout << strlen(buf[0]) << " " << strlen(buf[1]) << " " << strlen(buf[2]) << endl; assert(strlen(buf[0]) == 5 && strlen(buf[1]) == 5 && strlen(buf[2]) == 5); // astar.in中的每行数据长度必须为5 state.first = 0; for (int i = 0, p = 1; i < 3; ++i) { for (int j = 0; j < 6; j += 2) { if (buf[i][j] == "0") state.second = i * 3 + j / 2; // state.second为0（空格）在节点中的位置 else state.first += p * (buf[i][j] - "0"); p *= 10; } } /* 若初试节点为: 1 2 3 8 0 4 7 6 5 则state.first为567408321，state.second为4 */ return true;}//计算当前结点距目标的距离 int calculate(int current, int target) // return h=the sum of distances each block have to move to the right position,这里的each block不包括空格{ int c[9], t[9]; int i, cnt = 0; for (i = 0; i < 9; ++i) { c[current % 10] = t[target % 10] = i; current /= 10; target /= 10; } for (i = 1; i < 9; ++i) cnt += abs(c[i] / 3 - t[i] / 3) + abs(c[i] % 3 - t[i] % 3); return cnt; }//open表中结点间选择时的规则 f(n) = g(n) + h(n)class cmp { public: inline bool operator()(item a, item b) { return a.g + a.h > b.g + b.h; } }; //将整数形式表示转换为矩阵表示输出void pr(int state) { memset(buf, " ", sizeof(buf)); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 6; j += 2) { if (state % 10) buf[i][j] = state % 10 + "0"; state /= 10; } buf[i][5] = ""; puts(buf[i]); }}//用于判断当前空格是否可以向对应方向移动inline bool suit(int a, int b) //空格移动后的坐标为(a,b){ return (a >= 0 && a < 3 && b >= 0 && b < 3); } //递归输出搜索路径void path(int index) { if (index == 0) { pr(closed[index].first); puts(""); return; } path(closed[index].second); pr(closed[index].first); //将整数形式表示转换为矩阵表示输出 puts(""); ++steps; }int getNixuNum( int state ) //求节点的逆序对数{ int sum = 0; int result[9]; memset( result, 0, sizeof(result) ); //cout << result[8] << result[7] << endl; char buf[10]; itoa( state, buf, 10 ); //cout << buf << endl; int k = 0; while( buf[k] != "" ) { result[9-k-1] = buf[k] - "0"; k++; } for( int i = 0; i < 9; i++ ) { for( int j = i + 1; j < 9; j++ ) { if( result[i] && result[j] && result[i] > result[j] ) { sum++; } } } return sum; //返回3*3方格数组的逆序对数}int main() { //cout << getNixuNum(87654321); //open.resize(MAXSTEPS); unsigned int t1 = clock(); //cout << open.size() << endl; if( freopen("astar.in", "r", stdin) == NULL ) { cout << "file not find "; exit(0); }; freopen("astar2.out", "w", stdout); set<int>states; char tmp[100]; int i, x, y, a, b, nx, ny, end, next, index, kase = 0; pair<int,int> start, target; item head; //4个方向移动时的偏移量 const int xtran[4] = {-1, 0, 1, 0}; const int ytran[4] = {0, 1, 0, -1}; const int p[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000}; while (read(start)) // 读取初试状态节点 { unsigned int t2 = clock(); printf("Case %d: ", ++kase); gets(tmp); read(target); // 读取目标状态节点 gets(tmp); int targetNixuNum = getNixuNum(target.first); //若两者的逆序对数不是同为奇数或同为偶数，则无解 if( !(getNixuNum(start.first)&1 && targetNixuNum&1 || !(getNixuNum(start.first)&1) && !(targetNixuNum&1)) ) { cout << "无法从初始节点到终态节点 "; exit(0); } //初始化open表，将初始状态加入 open[0].state = start.first; open[0].h = calculate(start.first, target.first); // 计算当前节点到目标节点的估计距离 open[0].blank = start.second; open[0].pre = -1; // 初始节点无父节点 open[0].g = 0; // 初始节点的g为0 index = 0; states.insert(start.first); // 扩展过节点保存在states中，即出现过的状态保存在states中，states为set<int>类型，其中的states中的元素唯一 //提取open表中f值最小元素放入closed表，并对该结点进行扩展 for (end = 1; end > 0; ++index) // end为open表中的元素个数，一直循环到open表为空 { assert(index < MAXSTEPS); //临时存储 head = open[0]; // 由于使用pop_heap函数和push_heap函数，所以open[0]为g+h最小的元素 //放入closed表记录当前格局和由哪个结点扩展而来（该结点肯定已在closed表中） closed[index].first = open[0].state; //放入close表中，表示已经扩展完的节点，下面的for循环会扩展其节点 closed[index].second = open[0].pre; // index表示当前close表中当前扩展节点的下标 //从open表中删除该结点 pop_heap(open, open + end, cmp());//为algorithm文件中的函数，第一个参数指定开始位置，第二个指定结束，第三个指定比较函数 --end; //得到结果，递归输出路径 if (head.state == target.first) { path(index); break; } x = head.blank / 3; y = head.blank % 3; //空格在3*3方格中的x,y坐标 /* |2 0 3| A = |1 8 4| |7 6 5| // 看成3*3的数组 则head.blank=1 x=0,y=1,即空格的在3*3的数组中下标为(0,1) */ for (i = 0; i < 4; ++i) { nx = x + xtran[i]; ny = y + ytran[i]; /* i=0时：(nx,ny）为当前空格向上移动一格后的坐标 i=1时：(nx,ny）为当前空格向右移动一格后的坐标 i=2时：(nx,ny）为当前空格向下移动一格后的坐标 i=3时：(nx,ny）为当前空格向左移动一格后的坐标 */ if (suit(nx, ny)) // 判断是否能够移动 { a = head.blank; // 空格当前位置,以上面矩阵A为例，a=1 b = nx * 3 + ny; // 空格移动后的新位置,开始是能够向右边移动，故b=0*3+2=2 //调换十进制表示整数对应两个数字位 next = head.state + ((head.state % p[a + 1]) / p[a] - (head.state % p[b + 1]) / p[b]) * p[b] + ((head.state % p[b + 1]) / p[b] - (head.state % p[a + 1]) / p[a]) * p[a]; // 如head.state=567481302,空格向右移动一次后，next=567481032,即为移动后的节点 // 判断能否由当前节点到达目标节点 if( ( getNixuNum(next)&1 && targetNixuNum&1 ) || ( !(getNixuNum(next)&1) && !(targetNixuNum&1) ) ) { //判断是否已经扩展过，即已经出现过 if (states.find(next) == states.end()) //没出现就保存一下，也存入open表 { states.insert(next); open[end].pre = index; //扩展后的子节点，其父节点为当前扩展节点 open[end].blank = b; open[end].state = next; open[end].h = calculate(next,target.first); open[end].g = head.g + 1; ++end; //open表中元素加1 push_heap(open, open + end, cmp()); //压入堆中 } } } } } if (end <= 0) puts("No solution"); else { printf("Num of steps: %d ", steps); printf("Num of expanded: %d ", index); printf("Num of generated: %d ", index + end); printf("Time consumed: %d ", clock() - t2); } states.clear(); steps = 0; } printf("Total time consumed: %d ", clock() - t1); return 0;}

八数码 估价函数可以选h(s)=ΣΣ[|i-u230as[i,j]-1)/3u230b| + |j-(s[i,j]-1)mod3|]

题目地址:http://acm.pku.edu.cn/JudgeOnline/problem?id=1077BFS:#include <iostream>using namespace std;int fac[10]={1,1};bool tflag[9];struct bbit{ unsigned int val:4;};struct bbbit{ unsigned int val:2;};struct Node{ bbit s[9],pos; int step; bbbit path[21],tag; int hashval() { int ret=0,i,j,tmp; memset(tflag,false,sizeof(tflag)); for(i=0;i<8;i++) { tmp=0; for(j=0;j<s[i].val;j++) if(!tflag[j]) tmp++; ret+=tmp*fac[8-i]; tflag[s[i].val]=true; } return ret; } bool up() { if(pos.val<=2)return false; s[pos.val].val^=s[pos.val-3].val; s[pos.val-3].val^=s[pos.val].val; s[pos.val].val^=s[pos.val-3].val; path[step].val=0; pos.val-=3; return true; } bool down() { if(pos.val>=6)return false; s[pos.val].val^=s[pos.val+3].val; s[pos.val+3].val^=s[pos.val].val; s[pos.val].val^=s[pos.val+3].val; path[step].val=1; pos.val+=3; return true; } bool left() { if(pos.val==0||pos.val==3||pos.val==6)return false; s[pos.val].val^=s[pos.val-1].val; s[pos.val-1].val^=s[pos.val].val; s[pos.val].val^=s[pos.val-1].val; path[step].val=2; pos.val--; return true; } bool right() { if(pos.val==2||pos.val==5||pos.val==8)return false; s[pos.val].val^=s[pos.val+1].val; s[pos.val+1].val^=s[pos.val].val; s[pos.val].val^=s[pos.val+1].val; path[step].val=3; pos.val++; return true; } bool operator==(const Node&x)const { int i; for(i=0;i<9;i++)if(s[i].val!=x.s[i].val)return false; return true; }}Q[362880],S,A,tmp,top;struct Hash{ bool d1,d2; Node D;}hash[362880];inline void mkfac(){int i;for(i=2;i<=9;i++)fac[i]=fac[i-1]*i;}inline int eval(char c){return c=="x"?0:c-"0";}void o(Node x,Node y){ int i; for(i=1;i<=x.step;i++) { switch(x.path[i].val) { case 0:putchar("u");break; case 1:putchar("d");break; case 2:putchar("l");break; case 3:putchar("r");break; } } for(i=y.step;i>=1;i--) switch(y.path[i].val){ case 0:putchar("d");break; case 1:putchar("u");break; case 2:putchar("r");break; case 3:putchar("l");break; } puts("");}int main(){ char buf[11]; int i,t,l,r; bool flag; mkfac(); while(NULL!=gets(buf)) { t=0; for(i=0;i<=7;i++)A.s[i].val=i+1;A.s[8].val=0;A.pos.val=8; for(i=0;buf[i];i++) { if(buf[i]==" ")continue; S.s[t].val=eval(buf[i]); if(S.s[t].val==0) S.pos.val=t; t++; } l=r=0; flag=false; for(i=0;i<362880;i++)hash[i].d1=hash[i].d2=false; S.step=0;S.tag.val=1; A.step=0;A.tag.val=2; Q[r++]=S;//tag.val:1 Q[r++]=A;//tag.val:2 while(l<=r) { top=Q[l++]; top.step++; tmp=top; if(tmp.up()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.down()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.left()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.right()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } } AA:flag=true; if(!flag) puts("unsolvable"); } return 0;}A*:#include <iostream>#include <queue>using namespace std;int fac[10]={1,1};struct Node{ int s[9],step,pos; char path[501]; int hashval() { int ret=0,i,j,tmp; bool flag[9]; memset(flag,false,sizeof(flag)); for(i=0;i<8;i++) { tmp=0; for(j=0;j<s[i];j++) if(!flag[j]) tmp++; ret+=tmp*fac[8-i]; flag[s[i]]=true; } return ret; } bool up() { if(pos<=2)return false; s[pos]^=s[pos-3]; s[pos-3]^=s[pos]; s[pos]^=s[pos-3]; path[step]="u"; pos-=3; return true; } bool down() { if(pos>=6)return false; s[pos]^=s[pos+3]; s[pos+3]^=s[pos]; s[pos]^=s[pos+3]; path[step]="d"; pos+=3; return true; } bool left() { if(pos==0||pos==3||pos==6)return false; s[pos]^=s[pos-1]; s[pos-1]^=s[pos]; s[pos]^=s[pos-1]; path[step]="l"; pos--; return true; } bool right() { if(pos==2||pos==5||pos==8)return false; s[pos]^=s[pos+1]; s[pos+1]^=s[pos]; s[pos]^=s[pos+1]; path[step]="r"; pos++; return true; } bool operator==(const Node&x)const { int i; for(i=0;i<9;i++)if(s[i]!=x.s[i])return false; return true; } void show() { int i,j; for(i=0;i<=6;i+=3,cout<<endl) for(j=i;j<=i+2;j++) cout<<s[j]; } bool operator<(const Node&x)const { int la=0,lb=0,i; for(i=0;i<8;i++)if(s[i]!=i+1)la++;la+=(s[8]!=0); for(i=0;i<8;i++)if(x.s[i]!=i+1)lb++;lb+=(x.s[8]!=0); return la>lb; }}S,A,tmp,top;priority_queue<Node> Q;bool hash[362880];void mkfac(){int i;for(i=2;i<=9;i++)fac[i]=fac[i-1]*i;}int eval(char c){return c=="x"?0:c-"0";}void output(Node x){ int i; for(i=1;i<=x.step;i++) putchar(x.path[i]); puts("");}int main(){ char buf[11]; int i,t,l,r; bool flag; mkfac(); while(NULL!=gets(buf)) { t=0; for(i=0;i<=7;i++)A.s[i]=i+1;A.s[8]=0;A.pos=8; for(i=0;buf[i];i++) { if(buf[i]==" ")continue; S.s[t]=eval(buf[i]); if(S.s[t]==0) S.pos=t; t++; } l=r=0; flag=false; memset(hash,false,sizeof(hash)); S.step=0; while(!Q.empty())Q.pop(); Q.push(S); while(!Q.empty()) { top=Q.top(); Q.pop(); top.step++; tmp=top; if(tmp.up()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.down()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.left()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.right()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } } AA:flag=true; if(!flag) puts("unsolvable"); } return 0;}

其实A*算法也是一种最好优先的算法只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：f"(n)=g"(n)+h"(n)这里，f"(n)是估价函数，g"(n)是起点到节点n的最短路径值，h"(n)是n到目标的最短路经的启发值。由于这个f"(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g"(n)，但g(n)>=g"(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h"(n)，但h(n)<=h"(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h"(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

八数码问题： 取一个 3*3 的矩阵，将1-8(或者任意从小到大的八个数字)，随机分布在矩阵中，留下一个空格(可以用0代替)，作为初始状态；再去一个3*3的矩阵，将1-8(或者任意从小到大的八个数字，其取值必须与初始状态相同)，随机分布在矩阵中，留下一个空格(可以用0代替)，作为目标状态；对初始状态进行操作，其允许的操作是：将空格向上，下，左，右移动(即将空格与周边的数字进行交换)，操作初始状态的矩阵，在若干步后达目标状态。求解其过程为八数码问题。如图： 八数码问题的有解条件： 将矩阵从上到下从左到右的顺序分布成一个数列，并去掉空格，例如： 2 8 3 (0为空格) 分布成数列后： 1 0 4 u2003u2003u2003u20032 8 3 1 4 7 6 5 7 6 5 如果此 初始状态的数列(矩阵) 的 逆序数 与 目标状态的数列(矩阵) 的 逆序数 的 奇偶性一样 ，则此问题有解。 逆序数 的定义： 有一个数列，在这个数列中任意取一对数字(两个数字)，其两个数字在数列中的(从前到后)顺序与数字数值的大小相反，称其为一个逆序。这个数列中所有的逆序的和为逆序数。 证明 ： 空格向左右移动时，不改变逆序数的大小；空格向上下移动时，会改变逆序数，改变的幅度为±2或者0 (1)。所以±2或者0的改变幅度不会对逆序数造成奇偶性的改变。所以如果两个矩阵状态如果能互相到达，则必须有其逆序数的奇偶性一样。 (1) 在矩阵中操作空格上下移动时，在数列中的表现是将被交换的数字提前到他前面两个数字之前或者推后到他后面两个数字之后；例如，被交换的数字的下标是 Z 的话，空格向下移动(即被交换数向上移动)后，被交换数在数列中的位置是 Z-2 ；空格向上移动(即被交换数向下移动)后，则被交换数在数列中的位置是 Z+2。这种交换不会影响到被交换数与被它跨过的两个数以外的数字的顺序。比如说：被交换数的位置 Z ，如果空格向上移动，被交换数位置变成 Z+2，但是Z-1处的数字 与 Z 的顺序没有因为 Z 变成 Z+2 而失去了Z-1 在 Z 的前面的顺序，Z-1在Z前面，也在Z+2前面，同样的，Z变成Z+2也不会改变Z与Z+3的顺序。并且，如果有顺序 2 3 4 ，这个顺序的逆序数为0，如果我把4放到2 3前面，变成4 2 3，其逆序数就变成了+2，逆序数就增长了2；如果有顺序 4 2 3，其逆序数为+2，如果我把4放到2 3后面，变成2 3 4，其逆序数就变成了0，逆序数减少了2；如果有6 4 5，其逆序数为+2，如果我把5放在6 4 的前面，变成5 6 4，其逆序数为2，逆序数改变为0。所以改变的幅度为±2，或者0。 八数码问题的解法以及算法(宽度优先)： 解法： 空格可以上下左右移动，则父状态可以衍生出若干个子状态(考虑其空格不能越3*3的界以及其不返回到父状态或者父父状态等等之类的情况的话，最大的子状态数量为4 最小为0)，这种思路的话实际上这个问题就是一个树的搜索问题，所以用搜索的算法可以解决。 算法(宽度优先)： (1)判断初始状态与目标状态的逆序数的奇偶性来判断是否有解 (2)建立一个OPEN表(队列)，用于存放待展开子节点(状态)的父节点 (3)建立一个CLOSED表(队列)，用于存放已经展开了子节点的父节点 (4)将初始状态放到OPEN表中，作为第一个 (5)将OPEN表中第一个节点取出(并在OPEN表中删除这个节点)，放到CLOSED表中，排在CLOSED表中最后一个，整理好OPEN表 (6)把CLOSED表最后一个节点按照条件(不越界，不返回到父节点)展开其子节点，并且将可能的子节点按照顺序存入OPEN表中 (7)判断此父节点是否为目标状态： u2003①是，退出，打印答案 u2003②不是，回到步骤(4) 问题： (1)如果不用数字，而是用毫无关系的符号来填充矩阵，怎么判断是否有解呢？ 想法：将初始状态作为参考，将其不同的符号的顺序作为其符号的值的大小，计算出初始状态的逆序数为0，按照初始状态的值大小来判断目标状态的逆序数，然后判断奇偶性进而判断是否有解。

就是说金属杆运动过程中，会在回路里产生感应电流，有电流导体就要发热，焦耳热就是问的这个热量。这类题的通理通法是用功能关系做。

比特币病毒到底是什么?1、什么是比特币病毒？黑客发起的这个电脑病毒会将系统上的大量文件加密成为.onion为后缀的文件，中毒后被要求支付比特币赎金才能解密恢复文件，对个人资料造成严重损失，而杀毒软件并不能解密这些加密后的文件。2、根据网络安全机构通报，这是不法分子利用NSA黑客武器库泄漏的“永恒之蓝”发起的病毒攻击事件。3、为什么会叫比特币勒索病毒？所谓的比特币勒索病毒，其实是一种非对称文件加密病毒。4、知道网友你好，比特币病毒是一种“蠕虫式”的勒索病毒软件，由不法分子利用NSA泄露的危险漏洞”EternalBlue“进行传播。wannacry病毒对于密码技术的滥用包括Wannacry病毒利用密码技术的漏洞，实施了大规模的勒索攻击，给全球带来了毁灭性的影响。密码技术是保护信息安全的重要技术手段，但是滥用可能会给社会和个人利益带来损失。WannaCry病毒文件的大小3MB，是一款蠕虫勒索式恶意软件。除Windows10系统外，所有未及时安装MS17-010补丁的Windows系统都可能被攻击。WannaCry通过MS17-010漏洞进行快速感染和扩散，使用RSA+AES加密算法对文件进行加密。WannaCry也被称为WannaCrypt/WannaCrypt0r，目前还没有统一的中文名称，目前很多媒体按照字面翻译为“想哭”。此病毒文件的大小3MB，是一款蠕虫勒索式恶意软件。WannaCry（又叫WannaDecryptor），一种“蠕虫式”的勒索病毒软件，大小3MB，由不法分子利用NSA（NationalSecurityAgency，美国国家安全局）泄露的危险漏洞“EternalBlue”（永恒之蓝）进行传播[1]。勒索病毒是由rsa和什么加密1、以RSA、AES等多种加密算法对用户文件进行加密，并以此索要赎金。该类勒索病毒已经成为当前勒索病毒的主要类型，以WannaCry为代表。今年WannaCry再度复苏，最常被攻击的主要是政府、军方单位，其次为制造业、银行、金融与医疗系统。2、通常，有很多加密算法，并且它们在过去几年中已经发展，但勒索软件病毒使用的主要算法是RSA（rivest-shamiradleman）和AES（高级加密标准）算法。他们的目标是覆盖文件或删除它，并在受害者的计算器上创建它的加密副本。3、勒索病毒利用各种加密算法对文件进行加密，要破解若非病毒开发者本人及其团体，必须拿到解密的私钥才有可能破解。4、勒索病毒是黑客通过锁屏、加密文件等方式劫持用户文件并以此敲诈用户钱财的恶意软件。5、直接进入MBR引导模式；只有在写MBR失败的情况下，病毒才会使用备用方案，利用Mischa勒索病毒加密磁盘文件。6、该病毒一般通过邮件传递。已经被加密过的文件无法被解密，大罗神仙IT精英一样无解。该软件先用des算法加密文件，再用rsa对des的秘钥进行加密。由于解密rsa的私钥在黑客手里，所以只有他能解密。

混沌算法是指混沌序列加密算法 。该算法首先用单向Hash函数把密钥散列为混沌映射的迭代初值 ,混沌序列经过数次迭代后才开始取用 ；然后将迭代生成的混沌序列值映射为ASCII码后与地图数据逐字节进行异或运算，考虑到实际计算中的有限精度效应 ，随步长改变混沌映射参数，采用实际的地图数据 。混沌算法能很快的找到全局覆盖最优值，只能迭代60次，但混沌搜索式的随机性、遍历性不如junxiao等圆映射公式好。junxiao等考虑了移动节点的能量，很好地实现了覆盖，但是只针对全向传感器。李靖等的粒子群算法融入了模拟退火和轮盘赌的思想，很好地解决了粒子群算法易陷入局部解，但此算法的覆盖提高率并不高。混沌密码学是一种新的密码加密算法，具有简单、高效、安全等优点。混沌密码学是混沌理论的一个重要的应用领域。混沌用于密码学主要依据混沌的基本特性，即随机性、遍历性、确定性和对初始条件的敏感性，混沌密码体系在结构上与传统密码学理论中的混淆和扩散概念联系起来，混沌理论和纯粹密码学之间的必然联系形成了混沌密码学。

计算进化稳定策略的方法主要有两大类：一是从动态过程出发，求出系统的平衡点，然后，再根据进化稳定策略的定义进行验证就可以了；另一种方法就是直接用进化稳定策略定义来求。第一种方法涉及到具体的动态过程，并且只要知道动态过程就很容易求出进化稳定策略，本文略（可以参考张良桥2001）。第二种方法就是通过定义来求，下面给出一种简单的处理方法。根据纳什均衡的定义可以知道，如果策略 是博弈的纳什均衡，那么，所有以正概率进入最优混合策略的纯策略都是最优的，参与人在所有这些纯策略所得的支付都是无差异的（见《博弈论与信息经济学》102-103页，张维迎），即有：表示混合策略中非零概率的纯策略。假定存在 且下标为 的纯策略满足 ，令B是矩阵A中对应于非零纯策略的 阶子矩阵。且令C为 矩阵，其中代表元素为： 。那么当且仅当C是负定的， 就是进化稳定策略(见John Haigh 1974)。证明：假定 ，并且存在 ，有 ，那么很明显有 ，其中 是第 个纯策略，即在与稳定策略者群体博弈时，突变策略者得到的支付比稳定策略者还要大，所以策略 不是进化稳定策略，所以式（6）是进化稳定策略的必要条件。因此，对应于非零概率的纯策略满足： ，对满足条件的策略 有（注意 ）：对任意 ，当且仅当有： 。综上所述，利用该方法来求进化稳定策略的步骤如下：首先，令 个非零混合策略，然后解 个方程： ，定义B，C再考察矩阵C的所有特征根是否都为负，若都是负则所得的策略就是进化稳定策略。如求对称博弈 ，它有两个进化稳定策略： 。如果某策略组合是严格纳什均衡策略，那么就可以直接得出它就是进化稳定策略，但如果是弱纳什均衡策略，那么就可运用上述的方法来进行判定。由此，可得到求博弈的进化稳定策略步骤：一是求出博弈所有的纳什均衡；二是由支付判断出其中的严格纳什均衡；三对非严格纳什均衡而言就代入上述方程，并判断是否为负定即可以求出博弈中所有进化稳定策略。

架构以及我理解中架构的本质在开始谈我对架构本质的理解之前，先谈谈对今天技术沙龙主题的个人见解，千万级规模的网站感觉数量级是非常大的，对这个数量级我们战略上 要重 视 它 ， 战术上又 要 藐 视 它。先举个例子感受一下千万级到底是什么数量级？现在很流行的优步(Uber)，从媒体公布的信息看，它每天接单量平均在百万左右， 假如每天有10个小时的服务时间，平均QPS只有30左右。对于一个后台服务器，单机的平均QPS可以到达800-1000，单独看写的业务量很简单 。为什么我们又不能说轻视它？第一，我们看它的数据存储，每天一百万的话，一年数据量的规模是多少？其次，刚才说的订单量，每一个订单要推送给附近的司机、司机要并发抢单，后面业务场景的访问量往往是前者的上百倍，轻松就超过上亿级别了。今天我想从架构的本质谈起之后，希望大家理解在做一些建构设计的时候，它的出发点以及它解决的问题是什么。架构，刚开始的解释是我从知乎上看到的。什么是架构？有人讲， 说架构并不是一 个很 悬 乎的 东西 ， 实际 上就是一个架子 ， 放一些 业务 和算法，跟我们的生活中的晾衣架很像。更抽象一点，说架构其 实 是 对 我 们 重复性业务 的抽象和我 们 未来 业务 拓展的前瞻，强调过去的经验和你对整个行业的预见。我们要想做一个架构的话需要哪些能力？我觉得最重要的是架构师一个最重要的能力就是你要有 战 略分解能力。这个怎么来看呢:第一，你必须要有抽象的能力，抽象的能力最基本就是去重，去重在整个架构中体现在方方面面，从定义一个函数，到定义一个类，到提供的一个服务，以及模板，背后都是要去重提高可复用率。第二， 分类能力。做软件需要做对象的解耦，要定义对象的属性和方法，做分布式系统的时候要做服务的拆分和模块化，要定义服务的接口和规范。第三， 算法（性能），它的价值体现在提升系统的性能，所有性能的提升，最终都会落到CPU，内存，IO和网络这4大块上。这一页PPT举了一些例子来更深入的理解常见技术背后的架构理念。第一个例子，在分布式系统我们会做 MySQL分 库 分表，我们要从不同的库和表中读取数据，这样的抽象最直观就是使用模板，因为绝大多数SQL语义是相同的，除了路由到哪个库哪个表，如果不使用Proxy中间件，模板就是性价比最高的方法。第二看一下加速网络的CDN，它是做速度方面的性能提升，刚才我们也提到从CPU、内存、IO、网络四个方面来考虑，CDN本质上一个是做网络智能调度优化，另一个是多级缓存优化。第三个看一下服务化，刚才已经提到了，各个大网站转型过程中一定会做服务化，其实它就是做抽象和做服务的拆分。第四个看一下消息队列，本质上还是做分类，只不过不是两个边际清晰的类，而是把两个边际不清晰的子系统通过队列解构并且异步化。新浪微博整体架构是什么样的接下我们看一下微博整体架构，到一定量级的系统整个架构都会变成三层，客户端包括WEB、安卓和IOS，这里就不说了。接着还都会有一个接口层， 有三个主要作用：第一个作用，要做 安全隔离，因为前端节点都是直接和用户交互，需要防范各种恶意攻击；第二个还充当着一个 流量控制的作用，大家知道，在2014年春节的时候，微信红包，每分钟8亿多次的请求，其实真正到它后台的请求量，只有十万左右的数量级（这里的数据可能不准），剩余的流量在接口层就被挡住了；第三，我们看对 PC 端和移 动 端的需求不一样的，所以我们可以进行拆分。接口层之后是后台，可以看到微博后台有三大块：一个是 平台服 务，第二， 搜索，第三， 大数据。到了后台的各种服务其实都是处理的数据。 像平台的业务部门，做的就是 数据存储和读 取，对搜索来说做的是 数据的 检 索，对大数据来说是做的数据的 挖掘。微博其实和淘宝是很类似微博其实和淘宝是很类似的。一般来说，第一代架构，基本上能支撑到用户到 百万 级别，到第二代架构基本能支撑到 千万 级别都没什么问题，当业务规模到 亿级别时，需要第三代的架构。从 LAMP 的架构到面向服 务 的架构，有几个地方是非常难的，首先不可能在第一代基础上通过简单的修修补补满足用户量快速增长的，同时线上业务又不能停， 这是我们常说的 在 飞 机上 换 引擎的 问题。前两天我有一个朋友问我，说他在内部推行服务化的时候，把一个模块服务化做完了，其他部门就是不接。我建议在做服务化的时候，首先更多是偏向业务的梳理，同时要找准一个很好的切入点，既有架构和服务化上的提升，业务方也要有收益，比如提升性能或者降低维护成本同时升级过程要平滑，建议开始从原子化服务切入，比如基础的用户服务， 基础的短消息服务，基础的推送服务。 第二，就是可 以做无状 态 服 务，后面会详细讲，还有数据量大了后需要做数据Sharding，后面会将。 第三代 架构 要解决的 问题，就是用户量和业务趋于稳步增加（相对爆发期的指数级增长），更多考虑技术框架的稳定性， 提升系统整体的性能，降低成本，还有对整个系统监控的完善和升级。大型网站的系统架构是如何演变的我们通过通过数据看一下它的挑战，PV是在10亿级别，QPS在百万，数据量在千亿级别。我们可用性，就是SLA要求4个9，接口响应最多不能超过150毫秒，线上所有的故障必须得在5分钟内解决完。如果说5分钟没处理呢？那会影响你年终的绩效考核。2015年微博DAU已经过亿。我们系统有上百个微服务，每周会有两次的常规上线和不限次数的紧急上线。我们的挑战都一样，就是数据量，bigger and bigger，用户体验是faster and faster，业务是more and more。互联网业务更多是产品体验驱动， 技 术 在 产 品 体验上最有效的贡献 ， 就是你的性能 越来越好 。 每次降低加载一个页面的时间，都可以间接的降低这个页面上用户的流失率。微博的技术挑战和正交分解法解析架构下面看一下 第三代的 架构 图 以及 我 们 怎么用正交分解法 阐 述。 我们可以看到我们从两个维度，横轴和纵轴可以看到。 一个 维 度 是 水平的 分层 拆分，第二从垂直的维度会做拆分。水平的维度从接口层、到服务层到数据存储层。垂直怎么拆分，会用业务架构、技术架构、监控平台、服务治理等等来处理。我相信到第二代的时候很多架构已经有了业务架构和技术架构的拆分。我们看一下， 接口层有feed、用户关系、通讯接口；服务层，SOA里有基层服务、原子服务和组合服务，在微博我们只有原子服务和组合服务。原子服务不依赖于任何其他服务，组合服务由几个原子服务和自己的业务逻辑构建而成 ，资源层负责海量数据的存储（后面例子会详细讲）。技 术框架解决 独立于 业务 的海量高并发场景下的技术难题，由众多的技术组件共同构建而成 。在接口层，微博使用JERSY框架，帮助你做参数的解析，参数的验证，序列化和反序列化；资源层，主要是缓存、DB相关的各类组件，比如Cache组件和对象库组件。监 控平台和服 务 治理 ， 完成系统服务的像素级监控，对分布式系统做提前诊断、预警以及治理。包含了SLA规则的制定、服务监控、服务调用链监控、流量监控、错误异常监控、线上灰度发布上线系统、线上扩容缩容调度系统等。

架构以及我理解中架构的本质在开始谈我对架构本质的理解之前，先谈谈对今天技术沙龙主题的个人见解，千万级规模的网站感觉数量级是非常大的，对这个数量级我们战略上 要重 视 它 ， 战术上又 要 藐 视 它。先举个例子感受一下千万级到底是什么数量级？现在很流行的优步(Uber)，从媒体公布的信息看，它每天接单量平均在百万左右， 假如每天有10个小时的服务时间，平均QPS只有30左右。对于一个后台服务器，单机的平均QPS可以到达800-1000，单独看写的业务量很简单 。为什么我们又不能说轻视它？第一，我们看它的数据存储，每天一百万的话，一年数据量的规模是多少？其次，刚才说的订单量，每一个订单要推送给附近的司机、司机要并发抢单，后面业务场景的访问量往往是前者的上百倍，轻松就超过上亿级别了。今天我想从架构的本质谈起之后，希望大家理解在做一些建构设计的时候，它的出发点以及它解决的问题是什么。架构，刚开始的解释是我从知乎上看到的。什么是架构？有人讲， 说架构并不是一 个很 悬 乎的 东西 ， 实际 上就是一个架子 ， 放一些 业务 和算法，跟我们的生活中的晾衣架很像。更抽象一点，说架构其 实 是 对 我 们 重复性业务 的抽象和我 们 未来 业务 拓展的前瞻，强调过去的经验和你对整个行业的预见。我们要想做一个架构的话需要哪些能力？我觉得最重要的是架构师一个最重要的能力就是你要有 战 略分解能力。这个怎么来看呢:第一，你必须要有抽象的能力，抽象的能力最基本就是去重，去重在整个架构中体现在方方面面，从定义一个函数，到定义一个类，到提供的一个服务，以及模板，背后都是要去重提高可复用率。第二， 分类能力。做软件需要做对象的解耦，要定义对象的属性和方法，做分布式系统的时候要做服务的拆分和模块化，要定义服务的接口和规范。第三， 算法（性能），它的价值体现在提升系统的性能，所有性能的提升，最终都会落到CPU，内存，IO和网络这4大块上。这一页PPT举了一些例子来更深入的理解常见技术背后的架构理念。第一个例子，在分布式系统我们会做 MySQL分 库 分表，我们要从不同的库和表中读取数据，这样的抽象最直观就是使用模板，因为绝大多数SQL语义是相同的，除了路由到哪个库哪个表，如果不使用Proxy中间件，模板就是性价比最高的方法。第二看一下加速网络的CDN，它是做速度方面的性能提升，刚才我们也提到从CPU、内存、IO、网络四个方面来考虑，CDN本质上一个是做网络智能调度优化，另一个是多级缓存优化。第三个看一下服务化，刚才已经提到了，各个大网站转型过程中一定会做服务化，其实它就是做抽象和做服务的拆分。第四个看一下消息队列，本质上还是做分类，只不过不是两个边际清晰的类，而是把两个边际不清晰的子系统通过队列解构并且异步化。新浪微博整体架构是什么样的接下我们看一下微博整体架构，到一定量级的系统整个架构都会变成三层，客户端包括WEB、安卓和IOS，这里就不说了。接着还都会有一个接口层， 有三个主要作用：第一个作用，要做 安全隔离，因为前端节点都是直接和用户交互，需要防范各种恶意攻击；第二个还充当着一个 流量控制的作用，大家知道，在2014年春节的时候，微信红包，每分钟8亿多次的请求，其实真正到它后台的请求量，只有十万左右的数量级（这里的数据可能不准），剩余的流量在接口层就被挡住了；第三，我们看对 PC 端和移 动 端的需求不一样的，所以我们可以进行拆分。接口层之后是后台，可以看到微博后台有三大块：一个是 平台服 务，第二， 搜索，第三， 大数据。到了后台的各种服务其实都是处理的数据。 像平台的业务部门，做的就是 数据存储和读 取，对搜索来说做的是 数据的 检 索，对大数据来说是做的数据的 挖掘。微博其实和淘宝是很类似微博其实和淘宝是很类似的。一般来说，第一代架构，基本上能支撑到用户到 百万 级别，到第二代架构基本能支撑到 千万 级别都没什么问题，当业务规模到 亿级别时，需要第三代的架构。从 LAMP 的架构到面向服 务 的架构，有几个地方是非常难的，首先不可能在第一代基础上通过简单的修修补补满足用户量快速增长的，同时线上业务又不能停， 这是我们常说的 在 飞 机上 换 引擎的 问题。前两天我有一个朋友问我，说他在内部推行服务化的时候，把一个模块服务化做完了，其他部门就是不接。我建议在做服务化的时候，首先更多是偏向业务的梳理，同时要找准一个很好的切入点，既有架构和服务化上的提升，业务方也要有收益，比如提升性能或者降低维护成本同时升级过程要平滑，建议开始从原子化服务切入，比如基础的用户服务， 基础的短消息服务，基础的推送服务。 第二，就是可 以做无状 态 服 务，后面会详细讲，还有数据量大了后需要做数据Sharding，后面会将。 第三代 架构 要解决的 问题，就是用户量和业务趋于稳步增加（相对爆发期的指数级增长），更多考虑技术框架的稳定性， 提升系统整体的性能，降低成本，还有对整个系统监控的完善和升级。大型网站的系统架构是如何演变的我们通过通过数据看一下它的挑战，PV是在10亿级别，QPS在百万，数据量在千亿级别。我们可用性，就是SLA要求4个9，接口响应最多不能超过150毫秒，线上所有的故障必须得在5分钟内解决完。如果说5分钟没处理呢？那会影响你年终的绩效考核。2015年微博DAU已经过亿。我们系统有上百个微服务，每周会有两次的常规上线和不限次数的紧急上线。我们的挑战都一样，就是数据量，bigger and bigger，用户体验是faster and faster，业务是more and more。互联网业务更多是产品体验驱动， 技 术 在 产 品 体验上最有效的贡献 ， 就是你的性能 越来越好 。 每次降低加载一个页面的时间，都可以间接的降低这个页面上用户的流失率。微博的技术挑战和正交分解法解析架构下面看一下 第三代的 架构 图 以及 我 们 怎么用正交分解法 阐 述。 我们可以看到我们从两个维度，横轴和纵轴可以看到。 一个 维 度 是 水平的 分层 拆分，第二从垂直的维度会做拆分。水平的维度从接口层、到服务层到数据存储层。垂直怎么拆分，会用业务架构、技术架构、监控平台、服务治理等等来处理。我相信到第二代的时候很多架构已经有了业务架构和技术架构的拆分。我们看一下， 接口层有feed、用户关系、通讯接口；服务层，SOA里有基层服务、原子服务和组合服务，在微博我们只有原子服务和组合服务。原子服务不依赖于任何其他服务，组合服务由几个原子服务和自己的业务逻辑构建而成 ，资源层负责海量数据的存储（后面例子会详细讲）。技 术框架解决 独立于 业务 的海量高并发场景下的技术难题，由众多的技术组件共同构建而成 。在接口层，微博使用JERSY框架，帮助你做参数的解析，参数的验证，序列化和反序列化；资源层，主要是缓存、DB相关的各类组件，比如Cache组件和对象库组件。监 控平台和服 务 治理 ， 完成系统服务的像素级监控，对分布式系统做提前诊断、预警以及治理。包含了SLA规则的制定、服务监控、服务调用链监控、流量监控、错误异常监控、线上灰度发布上线系统、线上扩容缩容调度系统等。

DN150的镀锌钢管支架,一般是防晃支架,类似U型支架,并按此计算单个长度;1 边长*2+横担2 横担长度可以按100+100+150=350计算3 边长 我一般算做1米~1.3米综上所述: DN150的镀锌钢管一个支架,为5号角钢2.35米~3米

给你一份详细的代码吧，已经编译运行确认了：#include <iostream>#include <string>using namespace std;typedef char chess[10]; //字符数组typedef int temparr[10]; //整型数组chess arr; //定义字符数组变量temparr brr; //定义整型数组变量int number,suc,n3,c3,n2,c2,n1,c1; void inarrdata(chess a) //初始化棋盘编号{ a[1]="1";a[2]="2";a[3]="3"; a[4]="4";a[5]="5";a[6]="6"; a[7]="7";a[8]="8";a[9]="9";}void display(chess a) //输出棋盘状态{ cout<<endl;cout<<endl; cout<<" "<<a[1]<<" "<<"|"<<" "<<a[2]<<" "<<"|"<<" "<<a[3]<<endl; cout<<" -----------"<<endl; cout<<" "<<a[4]<<" "<<"|"<<" "<<a[5]<<" "<<"|"<<" "<<a[6]<<endl; cout<<" -----------"<<endl; cout<<" "<<a[7]<<" "<<"|"<<" "<<a[8]<<" "<<"|"<<" "<<a[9]<<endl; cout<<endl;cout<<endl;}int arrfull() //判断还有没有下棋的位置{ int i; int arrf=0; for(i=1;i<=9;i++) if(i==arr[i]-48) //如果字符arr[i]-48等于i arrf=1; //那么arrf=1，也就是可以走棋 return arrf;}void cn(int line) //判断状态{ switch(line) { case 0:c3=c3+1;break; case 1:n2=n2+1;break; case 2:c2=c2+1;break; case 3:n1=n1+1;break; case 4:c1=c1+1;break; case 5:n3=n3+1;break; }}int linenum(char a,char b,char c) //判断状态{ int ln=6; if((a=="X")&&(b=="X")&&(c=="X")) ln=0; if(((a=="O")&&(b=="O")&&(c!="O"))||((a=="O")&&(b!="O")&&(c=="O"))||((a!="O")&&(b=="O")&&(c=="O"))) ln=1; if(((a=="X")&&(b=="X")&&(c!="X"))||((a=="X")&&(b!="X")&&(c=="X"))||((a!="X")&&(b=="X")&&(c=="X"))) ln=2; if(((a=="O")&&(b!="O")&&(c!="O"))||((a!="O")&&(b=="O")&&(c!="O"))||((a!="O")&&(b!="O")&&(c=="O"))) ln=3; if(((a=="X")&&(b!="X")&&(c!="x"))||((a!="X")&&(b=="X")&&(c!="X"))||((a!="X")&&(b!="X")&&(c=="X"))) ln=4;if((a=="O")&&(b=="O")&&(c=="O")) ln=5; return ln;}int maxbrr(int *br) //判断最大权值{ int temp,i,mb; temp=-888; for(i=1;i<=9;i++) { if(temp<=br[i]) { temp=br[i]; mb=i; } } return mb;}void manstep() //人走棋处理模块{ int j; display(arr); if(arrfull()) //如果棋盘上还有下棋的位置，人走一步棋 { cout<<"您要走哪一步？请输入数字（1--9）:"; cin>>j; while((j<1)||(j>9)||(j!=arr[j]-48)) { cout<<"对不起，您输入的数字不对，请重新输入（1--9）:"; cin>>j; } arr[j]="O"; n3=0;c3=0;n2=0;c2=0;n1=0;c1=0; number=linenum(arr[1],arr[2],arr[3]);cn(number); number=linenum(arr[4],arr[5],arr[6]);cn(number); number=linenum(arr[7],arr[8],arr[9]);cn(number); number=linenum(arr[1],arr[4],arr[7]);cn(number); number=linenum(arr[2],arr[5],arr[8]);cn(number); number=linenum(arr[3],arr[6],arr[9]);cn(number); number=linenum(arr[1],arr[5],arr[9]);cn(number); number=linenum(arr[3],arr[5],arr[7]);cn(number); if(n3!=0) //您赢了 { display(arr); cout<<endl; cout<<"恭喜您赢了!!!"<<endl; suc=0; } }}void computerstep() //计算机走棋处理模块{ int i; if(arrfull()) //如果棋盘上还有可下棋的位置，则计算机走棋 { for(i=1;i<=9;i++) //对每一步可走的棋进行计算 { if(i==arr[i]-48) { c3=0;n2=0;c2=0;n1=0;c1=0; arr[i]="X"; number=linenum(arr[1],arr[2],arr[3]);cn(number); number=linenum(arr[4],arr[5],arr[6]);cn(number); number=linenum(arr[7],arr[8],arr[9]);cn(number); number=linenum(arr[1],arr[4],arr[7]);cn(number); number=linenum(arr[2],arr[5],arr[8]);cn(number); number=linenum(arr[3],arr[6],arr[9]);cn(number); number=linenum(arr[1],arr[5],arr[9]);cn(number); number=linenum(arr[3],arr[5],arr[7]);cn(number); brr[i]=(128*c3-63*n2+31*c2-15*n1+7*c1); //计算此步权值 arr[i]=i+48; } else brr[i]=-999; } arr[maxbrr(brr)]="X"; //确定计算机走哪一步，权值最大的一步 c3=0;n2=0;c2=0;n1=0;c1=0; number=linenum(arr[1],arr[2],arr[3]);cn(number); number=linenum(arr[4],arr[5],arr[6]);cn(number); number=linenum(arr[7],arr[8],arr[9]);cn(number); number=linenum(arr[1],arr[4],arr[7]);cn(number); number=linenum(arr[2],arr[5],arr[8]);cn(number); number=linenum(arr[3],arr[6],arr[9]);cn(number); number=linenum(arr[1],arr[5],arr[9]);cn(number); number=linenum(arr[3],arr[5],arr[7]);cn(number); if(c3!=0) //计算机已赢 { display(arr); cout<<endl; cout<<"计算机赢了!!!"<<endl; suc=0; } } else suc=0;}int main(){ cout<<"游戏规则："<<endl<<"棋盘格式如图，人和计算机在棋盘上交替走棋"<<endl; cout<<"约定计算机使用符号X，人使用符号O"<<endl; cout<<"谁先使一横行或一竖行或对角线上有三个自己的符号，就胜利了！"<<endl; string s="y"; string ch; while(s=="y"||s=="Y") { inarrdata(arr); //棋盘坐标编号 display(arr); //显示初始棋盘 suc=1; cout<<"请选择您是否先走?(y/n)"; cin>>ch; while(ch!="y"&&ch!="Y"&&ch!="n"&&ch!="N") { cout<<"错误!请输入y或n:"; cin>>ch; } if((ch=="y")||(ch=="Y")) //输入Y，表示人先走棋 { while(suc) { manstep(); computerstep(); } } else //计算机先走棋 { while(suc) { computerstep(); if(suc) manstep(); } } if(n3==0&&c3==0) cout<<endl<<"和棋!"<<endl<<endl; cout<<"再来一盘(y/n)?"; cin>>s; while(s!="y"&&s!="Y"&&s!="n"&&s!="N") { cout<<"错误!请输入y或n:"; cin>>s; } } return 0;}

单纯形法是是保证b>=0，通过转轴，使得检验数r>=0来求得最优解，而使用对偶单纯形法的前提是r<=0，通过转轴，使得达到b>=0。再看看别人怎么说的。

单纯形法是是保证b>=0，通过转轴，使得检验数r>=0来求得最优解，而使用对偶单纯形法的前提是r<=0，通过转轴，使得达到b>=0。

例1 把2x^2;-7x+3分解因式. 分析：先分解二次项系数，分别写在十字交叉线的左上角和左下角，再分解常数项，分 别写在十字交叉线的右上角和右下角，然后交叉相乘，求代数和，使其等于一次项系数. 分解二次项系数(只取正因数)： 2＝1×2＝2×1； 分解常数项： 3=1×3=3×1=(-3)×(-1)=(-1)×(-3). 用画十字交叉线方法表示下列四种情况： 1 1 ╳ 2 3 1×3+2×1 =5 1 3 ╳ 2 1 1×1+2×3 =7 1 -1 ╳ 2 -3 1×(-3)+2×(-1) =-5 1 -3 ╳ 2 -1 1×(-1)+2×(-3) =-7 经过观察，第四种情况是正确的，这是因为交叉相乘后，两项代数和恰等于一次项系数－7. 解 2x^2;-7x+3=(x-3)(2x-1). 一般地，对于二次三项式ax2+bx+c(a≠0)，如果二次项系数a可以分解成两个因数之积，即a=a1a2，常数项c可以分解成两个因数之积，即c=c1c2，把a1，a2，c1，c2，排列如下： a1 c1 ╳ a2 c2 a1a2+a2c1 按斜线交叉相乘，再相加，得到a1c2+a2c1，若它正好等于二次三项式ax2+bx+c的一次项系数b，即a1c2+a2c1=b，那么二次三项式就可以分解为两个因式a1x+c1与a2x+c2之积，即 ax2+bx+c=(a1x+c1)(a2x+c2). 像这种借助画十字交叉线分解系数，从而帮助我们把二次三项式分解因式的方法，通常叫做十字相乘法. 例2 把6x^2-7x-5分解因式. 分析：按照例1的方法，分解二次项系数6及常数项-5，把它们分别排列，可有8种不同的排列方法，其中的一种 2 1 ╳ 3 -5 2×(-5)+3×1=-7 是正确的，因此原多项式可以用十字相乘法分解因式. 解 6x^2-7x-5=(2x+1)(3x-5) 指出：通过例1和例2可以看到，运用十字相乘法把一个二次项系数不是1的二次三项式因式分解，往往要经过多次观察，才能确定是否可以用十字相乘法分解因式. 对于二次项系数是1的二次三项式，也可以用十字相乘法分解因式，这时只需考虑如何把常数项分解因数.例如把x^2+2x-15分解因式，十字相乘法是 1 -3 ╳ 1 5 1×5+1×(-3)=2 所以x^2+2x-15=(x-3)(x+5). 例3 把5x^2+6xy-8y^2分解因式. 分析：这个多项式可以看作是关于x的二次三项式，把-8y^2看作常数项，在分解二次项及常数项系数时，只需分解5与-8，用十字交叉线分解后，经过观察，选取合适的一组，即 1 2 ╳ 5 -4 1×(-4)+5×2=6 解 5x^2+6xy-8y^2=(x+2y)(5x-4y). 指出：原式分解为两个关于x，y的一次式. 例4 把(x-y)(2x-2y-3)-2分解因式. 分析：这个多项式是两个因式之积与另一个因数之差的形式，只有先进行多项式的乘法运算，把变形后的多项式再因式分解. 问：两上乘积的因式是什么特点，用什么方法进行多项式的乘法运算最简便? 答：第二个因式中的前两项如果提出公因式2，就变为2(x-y)，它是第一个因式的二倍，然后把(x-y)看作一个整体进行乘法运算，可把原多项式变形为关于(x-y)的二次三项式，就可以用十字相乘法分解因式了. 解 (x-y)(2x-2y-3)-2 =(x-y)[2(x-y)-3]-2 =2(x-y) ^2-3(x-y)-2 =[(x-y)-2][2(x-y)+1] =(x-y-2)(2x-2y+1). 1 -2 ╳ 2 1 1×1+2×(-2)=－3 指出：把(x-y)看作一个整体进行因式分解，这又是运用了数学中的“整体”思想方法. 例5 x^2+2x-15 分析：常数项(-15)<0，可分解成异号两数的积，可分解为(-1)(15)，或(1)(-15)或(3) (-5)或(-3)(5)，其中只有(-3)(5)中-3和5的和为2。 =(x-3)(x+5) 总结：①x^2＋（p+q）x＋pq型的式子的因式分解 这类二次三项式的特点是：二次项的系数是1；常数项是两个数的积；一次项系数是常数项的两个因数的和.因此，可以直接将某些二次项的系数是1的二次三项式因式分解： x^2＋(p+q)x＋pq＝(x＋p)(x＋q) ②kx^2＋mx＋n型的式子的因式分解 如果能够分解成k＝ac，n＝bd，且有ad＋bc＝m 时，那么 kx^2＋mx＋n＝(ax+b)(cx+d) a b ╳ c d

十字相乘法　　这种方法有两种情况。　　①x^2+(p+q)x+pq型的式子的因式分解 　　这类二次三项式的特点是：二次项的系数是1；常数项是两个数的积；一次项系数是常数项的两个因数的和。因此，可以直接将某些二次项的系数是1的二次三项式因式分解：x^2+(p+q)x+pq=(x+p)(x+q) ．　　②kx^2+mx+n型的式子的因式分解 　　如果如果有k=ac，n=bd，且有ad+bc=m时，那么kx^2+mx+n=(ax+b)(cx+d)．　　图示如下：　　·a b 　　·　×　　·c d 　　例如：因为　　·1 -3 　　·　×　　·7 2 　　且2-21=-19， 　　所以7x^2-19x-6=(7x+2)(x-3)．　　十字相乘法口诀：首尾分解，交叉相乘，求和凑中

国际四大快递，基本都是 21以内 按首重0.5kg，续重0.5kg计算，超过21公斤以上，多少钱每公斤，重量越大，价格越便宜。还有一个就是体积重量的问题，实际重量跟体积重量哪个重量大按哪个计算，体积重量=长*高*宽/5000除了国际四大快递，一些专线，像ARAMEX专线 DPEX专线等等，11公斤以上就有大货价格，体积重量 /6000计算还有一个EMS是不计泡，按实际重量，但是限制比较多，体积 1长+2高+2宽不能超过3米，单件实际重量不能超过30公斤，每一箱按一票货出，就是每一箱单独计费有需要您可以联系下我，我是做国际快递的

　　2011年UPS费率及相关调整通知　　感谢贵司对我司业务的大力支持！　　接到香港UPS和大陆UPS的最新通知，自2011年1月3日起，UPS运费费率调整情况如下：　　一、UPS出口运费费率调整：整体涨幅约5%—7%　　燃油附加费将会下调2%　　二、香港UPS与大陆UPS的货物计费重量计算标准更新如下：　　按每一件包裹的实际重量与体积重量取大者确定单件包裹的计费重量，每票包裹的计费重量为每一件包裹的计费重量之和；　　新的计费重量的标准只适用于国际快件包裹；　　注：对于一票多件的包裹，如果存在多种包裹尺寸，客户需要提供每一件包裹的尺寸和重量。　　例如：目前一票多件货物的计费重量计算方法：　　实重　　材积重　　实收重　　第一件包裹　　15.2　　10.1　　第二件包裹　　15.7　　20.2　　总计　　30.9　　30.3　　30.9　　客户收到的账单重量为30.9公斤。　　新的货物计费重量标准更新如下　　实重　　材积重　　实收重　　第一件包裹　　15.2　　10.1　　15.2　　第二件包裹　　15.7　　20.2　　20.2　　总计　　30.9　　30.3　　35.4　　客户收到的账单重量为36公斤。　　三、无法交付货件回邮费用（未能派送退件附加费）：如果货物被收件人拒收，或者因为其他的原因未能完成投递，UPS将尽力去联系发件人获得进一步的指示，如果发件人要求退运该件，则发件人将需要支付UPS未派送退运附加费：　　1、香港UPS为每票港币78元　　2、大陆UPS为每票人民币67元　　四、UPS服务分区更新　　香港UPS服务分区更新如下：　　国家　　服务更新　　2010年分区　　2011年分区　　Kosovo科索沃　　新增红单速快服务　　无　　9　　San Marino圣马力诺　　调整　　8　　6　　Andorra安道尔　　8　　6　　Bahrain 巴林；Croatia 克罗地亚；Egypt埃及； Iceland 冰岛；Jordan 约旦；Kazakhstan 哈萨克斯坦* ；Kuwait 科威特；Lebanon 黎巴嫩；Qatar 卡塔尔；Saudi Arabia沙特阿拉伯；　　新增红单速快服务　　无　　9　　Belarus/ Byelorussia白俄罗斯；Colombia哥伦比亚；Greenland 格林兰；Grenada 格林纳达；Guadeloupe； 厄德罗普；；Guatemala 危地马拉；Peru秘鲁；　　取消红单特快服务　　9　　无　　Guam 关岛　　取消红单特快服务　　7　　无　　Philippines菲律宾　　取消红单加急、特快服务　　4　　无　　大陆UPS服务分区更新如下：　　国家　　服务更新　　2010年分区　　2011年分区　　Kosovo科索沃　　新增红单速快服务　　无　　8　　San Marino圣马力诺　　调整　　8　　7　　Andorra安道尔　　8　　6　　Bahrain 巴林　　新增红单速快服务　　无　　8　　Croatia *克罗地亚　　无　　9　　Egypt埃及　　无　　8　　Iceland 冰岛　　无　　7　　Jordan 约旦　　无　　9　　Kazakhstan 哈萨克斯坦　　无　　9　　Kuwait科威特　　无　　8　　Lebanon 黎巴嫩　　无　　8　　Qatar 卡塔尔　　无　　9　　Saudi Arabia沙特阿拉伯　　无　　8　　Macau澳门　　取消红单加急、特快及蓝单服务　　1　　无　　Philippines菲律宾　　取消红单加急、特快服务　　4　　无　　Taiwan台湾　　2　　无

4的阶乘=4*3*2*1=24

下列关于二值形态学算法叙述错误的是？ A.二值形态学操作包括了二值膨胀、二值腐蚀以及开闭运算B.对图像进行重复的开操作会不断产生新的不同的结果C.二值膨胀可以使图像的前景区域扩大D.通过开闭运算的结合可以出去图像中的椒盐噪声正确答案：对图像进行重复的开操作会不断产生新的不同的结果

卷积在工程和数学上都有很多应用：统计学中，加权的滑动平均是一种卷积。概率论中，两个统计独立变量X与Y的和的概率密度函数是X与Y的概率密度函数的卷积。声学中，回声可以用源声与一个反映各种反射效应的函数的卷积表示。电子工程与信号处理中，任一个线性系统的输出都可以通过将输入信号与系统函数（系统的冲激响应）做卷积获得。物理学中，任何一个线性系统（符合叠加原理）都存在卷积。介绍一个实际的概率学应用例子。假设需求到位时间的到达率为poisson(λ)分布，需求的大小的分布函数为D（.)，则单位时间的需求量的分布函数为 F(x)：其中 D(k)(x)为k阶卷积。卷积是一种线性运算,图像处理中常见的mask运算都是卷积，广泛应用于图像滤波。castlman的书对卷积讲得很详细。高斯变换就是用高斯函数对图像进行卷积。高斯算子可以直接从离散高斯函数得到：for(i=0; i<N; i++){for(j=0; j<N; j++){g[i*N+j]=exp(-((i-(N-1)/2)^2+(j-(N-1)/2)^2))/(2*delta^2));sum += g[i*N+j];}}再除以 sum 得到归一化算子N是滤波器的大小，delta自选首先，在提到卷积之前，必须提到卷积出现的背景。卷积是在信号与线性系统的基础上或背景中出现的，脱离这个背景单独谈卷积是没有任何意义的，除了那个所谓褶反公式上的数学意义和积分（或求和，离散情况下）。信号与线性系统，讨论的就是信号经过一个线性系统以后发生的变化（就是输入 输出 和所经过的所谓系统，这三者之间的数学关系）。所谓线性系统的含义，就是，这个所谓的系统，带来的输出信号与输入信号的数学关系式之间是线性的运算关系。因此，实际上，都是要根据我们需要待处理的信号形式，来设计所谓的系统传递函数，那么这个系统的传递函数和输入信号，在数学上的形式就是所谓的卷积关系。卷积关系最重要的一种情况，就是在信号与线性系统或数字信号处理中的卷积定理。利用该定理，可以将时间域或空间域中的卷积运算等价为频率域的相乘运算，从而利用FFT等快速算法，实现有效的计算，节省运算代价。C++语言代码： void convolution(float *input1, float *input2, float *output, int mm, int nn){ float *xx = new float[mm+nn-1]; // do convolution for (int i = 0; i < mm+nn-1; i++) { xx[i] = 0.0; for (int j = 0; j < mm; j++) { if (i-j > 0 && i-j < nn) xx[i] += input1[j] * input2[i-j]; } } // set value to the output array for (int i = 0; i < mm; i++) output[i] = xx[i + (nn-1) / 2]; delete[] xx;}

主张东西二宅不能相混，东四命人宜住东四宅，西四命人宜住西四宅。究竟什么叫做西四宅呢？八宅风水学对西四宅东四宅进行了详细解释。西四宅概念“西四宅”是指坐西北朝东南(乾宅)、坐西南朝东北(坤宅)、坐东北朝西南(艮宅)和坐西朝东(兑宅)四种坐向的房子。“八宅派”认为要以人的“命卦”来决定。所谓“命卦”，就是根据人的出生年份推算出来的卦。如果推算出的卦为坎、离、震、巽四卦则为“东四命”，如为乾、坤、艮、兑四卦则为西四命。“八宅派”认为，命卦为“东四命”的人要住“东四宅”，“西四命”的人要住“西四宅”。由于“八宅派”理论在古代影响甚大，所以很多人都是根据“八宅派”理论来确定住宅朝向。相关阅读：西四宅是什么意思 为何西四命的人要住西四宅东四宅西四宅是什么意思 东四宅西四宅的判别东四命西四命是什么 东四命西四命算法解析西四宅与西四命吉凶如何匹配 八宅有八种卦象西四命住东四宅运势如何 西四命住东四宅如何化解

世勋94年的，现在应该是19，但是在韩国说年龄时要+1，所以他韩国年龄是20

char buff[1024],buff2[1024],key[1024];int len=0;strcpy(buff,"8FCDF875C1307114C43C07DE30F2D84B");strcpy(key,"yueguang");typedef int (WINAPI ICEPUB_DECRYPTTEXT2)(char *strInputHexstring, char *strOutput, char *strKey);ICEPUB_DECRYPTTEXT2 *icePub_decryptText2 = 0;HINSTANCE hDLLDrv = LoadLibrary("icePubDll.dll");if(hDLLDrv){ icePub_decryptText=(ICEPUB_DECRYPTTEXT2 *)GetProcAddress(hDLLDrv,"icePub_decryptText2");}if(icePub_decryptText2) len=icePub_decryptText2(buff,buff2,key);if(hDLLDrv) FreeLibrary(hDLLDrv);//AfxMessageBox(buff2);... ...if((user=="Crack")&&(pwd==buff2))//判断用户名和密码http://dl.icese.net/dev.php?f=icePubDll.rar 下载

首先看是不是PCODE,是用VBEXPLORER等工具，加上一些资料应该还是挺简单的不是PCODE先用C32ASM看字符串，再用OD到附近下断，基本上就到领空了。下来就是分析了。记得看雪有个VB的CHM,楼主可以找找看 ===========================你进op以后bpx soso(随便一个字符串) 一下，发现里面有大量的函数调用就是了

假设Mdis[v]表示从原点到节点V的最短路径长度，通过以下算法确定从原点出发的单源最短路径。1、选择一个还未扩展过的Mdis值最小的节点V*2、通过节点V*所连接的每一条边执行松弛操作，i.e. mdis[k] = min{mdis[k], mdis[v] + cost<v, k>}3、标记节点V为已扩展过，重复第一步直到所有节点都扩展过。以上算法的时间复杂度为O(n^2)，可以通过二叉堆优化到O(mlogn)

ECC是EllipticCurves Cryptography的缩写，意为椭圆曲线密码编码学。和RSA算法一样，ECC算法也属于公开密钥算法.与RSA算法相比，ECC算法在安全性和性能上更好，破解难度更大，但是就目前而言，ECC加密算法的应用范围不及RSA算法那么广泛。不过如果您需要这2种加密算法，国内老牌证书平台锐诚信息可以签发RSA 和ECC算法的SSL证书。

决策树是通过一系列规则对数据进行分类的过程。它提供一种在什么条件下会得到什么值的类似规则的方法。决策树分为分类树和回归树两种，分类树对离散变量做决策树，回归树对连续变量做决策树。 如果不考虑效率等，那么样本所有特征的判断级联起来终会将某一个样本分到一个类终止块上。实际上，样本所有特征中有一些特征在分类时起到决定性作用，决策树的构造过程就是找到这些具有决定性作用的特征，根据其决定性程度来构造一个倒立的树--决定性作用最大的那个特征作为根节点，然后递归找到各分支下子数据集中次大的决定性特征，直至子数据集中所有数据都属于同一类。所以，构造决策树的过程本质上就是根据数据特征将数据集分类的递归过程，我们需要解决的第一个问题就是，当前数据集上哪个特征在划分数据分类时起决定性作用。 一棵决策树的生成过程主要分为以下3个部分: 特征选择：特征选择是指从训练数据中众多的特征中选择一个特征作为当前节点的分裂标准，如何选择特征有着很多不同量化评估标准标准，从而衍生出不同的决策树算法。 决策树生成： 根据选择的特征评估标准，从上至下递归地生成子节点，直到数据集不可分则停止决策树停止生长。 树结构来说，递归结构是最容易理解的方式。 剪枝：决策树容易过拟合，一般来需要剪枝，缩小树结构规模、缓解过拟合。剪枝技术有预剪枝和后剪枝两种。 划分数据集的最大原则是：使无序的数据变的有序。如果一个训练数据中有20个特征，那么选取哪个做划分依据？这就必须采用量化的方法来判断，量化划分方法有多重，其中一项就是“信息论度量信息分类”。基于信息论的决策树算法有ID3、CART和C4.5等算法，其中C4.5和CART两种算法从ID3算法中衍生而来。 CART和C4.5支持数据特征为连续分布时的处理，主要通过使用二元切分来处理连续型变量，即求一个特定的值-分裂值：特征值大于分裂值就走左子树，或者就走右子树。这个分裂值的选取的原则是使得划分后的子树中的“混乱程度”降低，具体到C4.5和CART算法则有不同的定义方式。 ID3算法由Ross Quinlan发明，建立在“奥卡姆剃刀”的基础上：越是小型的决策树越优于大的决策树（be simple简单理论）。ID3算法中根据信息论的信息增益评估和选择特征，每次选择信息增益最大的特征做判断模块。ID3算法可用于划分标称型数据集，没有剪枝的过程，为了去除过度数据匹配的问题，可通过裁剪合并相邻的无法产生大量信息增益的叶子节点（例如设置信息增益阀值）。使用信息增益的话其实是有一个缺点，那就是它偏向于具有大量值的属性--就是说在训练集中，某个属性所取的不同值的个数越多，那么越有可能拿它来作为分裂属性，而这样做有时候是没有意义的，另外ID3不能处理连续分布的数据特征，于是就有了C4.5算法。CART算法也支持连续分布的数据特征。 C4.5是ID3的一个改进算法，继承了ID3算法的优点。C4.5算法用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值多的属性的不足在树构造过程中进行剪枝；能够完成对连续属性的离散化处理；能够对不完整数据进行处理。C4.5算法产生的分类规则易于理解、准确率较高；但效率低，因树构造过程中，需要对数据集进行多次的顺序扫描和排序。也是因为必须多次数据集扫描，C4.5只适合于能够驻留于内存的数据集。 CART算法的全称是Classification And Regression Tree，采用的是Gini指数（选Gini指数最小的特征s）作为分裂标准,同时它也是包含后剪枝操作。ID3算法和C4.5算法虽然在对训练样本集的学习中可以尽可能多地挖掘信息，但其生成的决策树分支较大，规模较大。为了简化决策树的规模，提高生成决策树的效率，就出现了根据GINI系数来选择测试属性的决策树算法CART。 决策树算法的优点： （1）便于理解和解释，树的结构可以可视化出来 （2）基本不需要预处理，不需要提前归一化，处理缺失值 （3）使用决策树预测的代价是O(log2m)，m为样本数 （4）能够处理数值型数据和分类数据 （5）可以处理多维度输出的分类问题 （6）可以通过数值统计测试来验证该模型，这使解释验证该模型的可靠性成为可能 （7）即使该模型假设的结果与真实模型所提供的数据有些违反，其表现依旧良好 决策树算法的缺点: （1）决策树模型容易产生一个过于复杂的模型,这样的模型对数据的泛化性能会很差。这就是所谓的过拟合.一些策略像剪枝、设置叶节点所需的最小样本数或设置数的最大深度是避免出现该问题最为有效地方法。 （2）决策树可能是不稳定的，因为数据中的微小变化可能会导致完全不同的树生成。这个问题可以通过决策树的集成来得到缓解。 （3）在多方面性能最优和简单化概念的要求下，学习一棵最优决策树通常是一个NP难问题。因此，实际的决策树学习算法是基于启发式算法，例如在每个节点进行局部最优决策的贪心算法。这样的算法不能保证返回全局最优决策树。这个问题可以通过集成学习来训练多棵决策树来缓解,这多棵决策树一般通过对特征和样本有放回的随机采样来生成。 （4）有些概念很难被决策树学习到,因为决策树很难清楚的表述这些概念。例如XOR，奇偶或者复用器的问题。 （5）如果某些类在问题中占主导地位会使得创建的决策树有偏差。因此，我们建议在拟合前先对数据集进行平衡。 （1）当数据的特征维度很高而数据量又很少的时候，这样的数据在构建决策树的时候往往会过拟合。所以我们要控制样本数量和特征的之间正确的比率； （2）在构建决策树之前，可以考虑预先执行降维技术（如PCA，ICA或特征选择），以使我们生成的树更有可能找到具有辨别力的特征； （3）在训练一棵树的时候，可以先设置max_depth=3来将树可视化出来，以便我们找到树是怎样拟合我们数据的感觉，然后在增加我们树的深度； （4）树每增加一层，填充所需的样本数量是原来的2倍，比如我们设置了最小叶节点的样本数量，当我们的树层数增加一层的时候，所需的样本数量就会翻倍，所以我们要控制好树的最大深度，防止过拟合； （5）使用min_samples_split（节点可以切分时拥有的最小样本数） 和 min_samples_leaf（最小叶节点数）来控制叶节点的样本数量。这两个值设置的很小通常意味着我们的树过拟合了，而设置的很大意味着我们树预测的精度又会降低。通常设置min_samples_leaf=5； （6）当树的类比不平衡的时候，在训练之前一定要先平很数据集，防止一些类别大的类主宰了决策树。可以通过采样的方法将各个类别的样本数量到大致相等，或者最好是将每个类的样本权重之和(sample_weight)规范化为相同的值。另请注意，基于权重的预剪枝标准（如min_weight_fraction_leaf）将比不知道样本权重的标准（如min_samples_leaf）更少偏向主导类别。 （7）如果样本是带权重的，使用基于权重的预剪枝标准将更简单的去优化树结构，如mn_weight_fraction_leaf，这确保了叶节点至少包含了样本权值总体总和的一小部分； （8）在sklearn中所有决策树使用的数据都是np.float32类型的内部数组。如果训练数据不是这种格式，则将复制数据集，这样会浪费计算机资源。 （9）如果输入矩阵X非常稀疏，建议在调用fit函数和稀疏csr_matrix之前转换为稀疏csc_matrix，然后再调用predict。 当特征在大多数样本中具有零值时，与密集矩阵相比，稀疏矩阵输入的训练时间可以快几个数量级。