遗传算法的C语言实现(二)-----以求解TSP问题为例
上一次我们使用遗传算法求解了一个较为复杂的多元非线性函数的极值问题，也基本了解了遗传算法的实现基本步骤。这一次，我再以经典的TSP问题为例，更加深入地说明遗传算法中选择、交叉、变异等核心步骤的实现。而且这一次解决的是离散型问题，上一次解决的是连续型问题，刚好形成对照。
首先介绍一下TSP问题。TSP(traveling salesman problem,旅行商问题)是典型的NP完全问题，即其最坏情况下的时间复杂度随着问题规模的增大按指数方式增长，到目前为止还没有找到一个多项式时间的有效算法。TSP问题可以描述为：已知n个城市之间的相互距离，某一旅行商从某一个城市出发，访问每个城市一次且仅一次，最后回到出发的城市，如何安排才能使其所走的路线最短。换言之，就是寻找一条遍历n个城市的路径，或者说搜索自然子集X={1,2,...,n}(X的元素表示对n个城市的编号)的一个排列P(X)={V1,V2,....,Vn},使得Td=∑d(Vi,Vi+1)+d(Vn,V1)取最小值，其中,d(Vi,Vi+1)表示城市Vi到Vi+1的距离。TSP问题不仅仅是旅行商问题，其他许多NP完全问题也可以归结为TSP问题，如邮路问题，装配线上的螺母问题和产品的生产安排问题等等，也使得TSP问题的求解具有更加广泛的实际意义。
再来说针对TSP问题使用遗传算法的步骤。
（1）编码问题：由于这是一个离散型的问题，我们采用整数编码的方式，用1~n来表示n个城市，1~n的任意一个排列就构成了问题的一个解。可以知道，对于n个城市的TSP问题，一共有n!种不同的路线。
(2)种群初始化：对于N个个体的种群，随机给出N个问题的解（相当于是染色体）作为初始种群。这里具体采用的方法是：1,2，...,n作为第一个个体，然后2,3，..n分别与1交换位置得到n-1个解，从2开始，3,4,...,n分别与2交换位置得到n-2个解，依次类推。（如果这样还不够初始种群的数量，可以再考虑n,n-1,...,1这个序列，然后再按照相同的方法生成，等等）
(3)适应度函数：设一个解遍历初始行走的总距离为D，则适应度fitness=1/D.即总距离越高，适应度越低，总距离越低（解越好），适应度越高。
(4) 选择操作：个体被选中的概率与适应度成正比，适应度越高，个体被选中的概率越大。这里仍然采用轮盘赌法。
(5) 交叉操作：交叉操作是遗传算法最重要的操作，是产生新个体的主要来源，直接关系到算法的全局寻优能力，这里采用部分映射交叉。比如对于n=10的情况，对于两个路径: 1 2 4 5 6 3 9 10 8 7
3 9 7 6 8 10 5 1 2 4
随机产生两个[1,10]之间的随机数r1，r2，代表选择交叉的位置，比如r1=2，r2=4,如上图标红的位置，将第一个个体r1到r2之间的基因(即城市序号)与第二个个体r1到r2之间的基因交换，交换之后变为:
1 9 7 6 6 3 9 10 8 7
3 2 4 5 8 10 5 1 2 4
黄色部分表示交叉过来的基因，这个时候会发现可能交叉过来的基因与原来其他位置上的基因有重复，容易直到，第一个个体重复基因的数目与第二个个体重复基因的数目是相同的（这里都是3个），只需要把第一个个体重复的基因(用绿色标识)与第二个个体重复的基因做交换，即可以消除冲突。消除冲突之后的解如下:
1 9 7 6 5 3 2 10 8 4
3 2 4 5 8 10 6 1 9 7
(6)变异操作:变异操作采取对于一个染色体(即个体)随机选取两个基因进行交换的策略。比如对于染色体:
2 4 6 10 3 1 9 7 8 5
随机选取了两个位置p1=3,p2=8(标红位置),交换这两个位置的基因，得到新的染色体为:
2 4 7 10 3 1 9 6 8 5
（7） 进化逆转操作：这个是标准的遗传算法没有的，是我们为了加速进化而加入的一个操作。这里的进化是指逆转操作具有单向性，即只有逆转之后个体变得更优才会执行逆转操作，否则逆转无效。具体的方法是，随机产生[1,10](这里仍然以10个城市为例)之间的两个随机数r1和r2(其实也是允许相同的，只是r1,r2相同之后，逆转自然无效,设置交叉变异都是无效的，但是这不会经常发生),然后将r1和r2之间的基因进行反向排序。比如对于染色体:
1 3 4 2 10 9 8 7 6 5
r1=3,r2=5，它们之间的基因(标红位置)反向排列之后得到的染色体如下:
1 3 10 2 4 9 8 7 6 5
根据以上的步骤，我们就可以比较容易写出用遗传算法求解TSP问题的具体代码了，这里仍然使用C语言。先以规模比较小的城市为例,这里取14个，城市之间的距离会直接在代码中给出。代码如下：
/*
*遗传算法(GA) 解决TSP 问题
*案例参考自《MATLAB 智能算法30个案例分析》
*本例以14个城市为例，14个城市的位置坐标如下(括号内第一个元素为X坐标，第二个为纵坐标)：1:(16.47,96.10) 2:(16.47,94.44) 3:(20.09,92.54)
*4:(22.39,93.37) 5:(25.23,97.24) 6:(22.00,96.05) 7:(20.47,97.02) 8:(17.20,96.29) 9:(16.30,97.38) 10:(14.05,98.12) 11:(16.53,97.38)
*12:(21.52,95.59) 13:(19.41,97.13) 14:(20.09,92.55)
*遗传算法实现的步骤为:(1)编码 (2) 种群初始化 (3) 构造适应度函数 (4) 选择操作 (5) 交叉操作 (6) 变异操作 (7) 进化逆转操作
* 具体实现的步骤这里不详细说，参考《MATLAB 智能算法30个案例分析》P38 - P40
* update in 16/12/4
* author:Lyrichu
* email:919987476@qq.com
*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
#define maxgen 200 // 最大进化代数
#define sizepop 100 // 种群数目
#define pcross 0.6 // 交叉概率
#define pmutation 0.1 // 变异概率
#define lenchrom 14 // 染色体长度(这里即为城市个数)
double city_pos[lenchrom][] = {{16.47,96.10},{16.47,94.44},{20.09,92.54},{22.39,93.37},{25.23,97.24},{22.00,96.05},{20.47,97.02},
{17.20,96.29},{16.30,97.38},{14.05,98.12},{16.53,97.38},{21.52,95.59},{19.41,97.13},{20.09,92.55}}; // 定义二维数组存放14个城市的X、Y坐标
int chrom[sizepop][lenchrom]; // 种群
int best_result[lenchrom]; // 最佳路线
double min_distance; // 最短路径长度 // 函数声明
void init(void); // 种群初始化函数
double distance(double *,double *); // 计算两个城市之间的距离
double * min(double *); // 计算距离数组的最小值
double path_len(int *); // 计算某一个方案的路径长度，适应度函数为路线长度的倒数
void Choice(int [sizepop][lenchrom]); // 选择操作
void Cross(int [sizepop][lenchrom]); // 交叉操作
void Mutation(int [sizepop][lenchrom]); // 变异操作
void Reverse(int [sizepop][lenchrom]); // 逆转操作 // 种群初始化
void init(void)
{
int num = ;
while(num < sizepop)
{
for(int i=;i<sizepop;i++)
for(int j=;j<lenchrom;j++)
chrom[i][j] = j+;
num++;
for(int i=;i<lenchrom-;i++)
{
for(int j=i+;j<lenchrom;j++)
{
int temp = chrom[num][i];
chrom[num][i] = chrom[num][j];
chrom[num][j] = temp; // 交换第num个个体的第i个元素和第j个元素
num++;
if(num >= sizepop)
break;
}
if(num >= sizepop)
break;
}
// 如果经过上面的循环还是无法产生足够的初始个体，则随机再补充一部分
// 具体方式就是选择两个基因位置，然后交换
while(num < sizepop)
{
double r1 = ((double)rand())/(RAND_MAX+1.0);
double r2 = ((double)rand())/(RAND_MAX+1.0);
int p1 = (int)(lenchrom*r1); // 位置1
int p2 = (int)(lenchrom*r2); // 位置2
int temp = chrom[num][p1];
chrom[num][p1] = chrom[num][p2];
chrom[num][p2] = temp; // 交换基因位置
num++;
}
}
} // 距离函数
double distance(double * city1,double * city2)
{
double x1 = *city1;
double y1 = *(city1+);
double x2 = *(city2);
double y2 = *(city2+);
double dis = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dis;
}
// min()函数
double * min(double * arr)
{
static double best_index[];
double min_dis = *arr;
double min_index = ;
for(int i=;i<sizepop;i++)
{
double dis = *(arr+i);
if(dis < min_dis)
{
min_dis = dis;
min_index = i;
}
}
best_index[] = min_index;
best_index[] = min_dis;
return best_index;
} // 计算路径长度
double path_len(int * arr)
{
double path = ; // 初始化路径长度
int index = *arr; // 定位到第一个数字(城市序号)
for(int i=;i<lenchrom-;i++)
{
int index1 = *(arr+i);
int index2 = *(arr+i+);
double dis = distance(city_pos[index1-],city_pos[index2-]);
path += dis;
}
int last_index = *(arr+lenchrom-); // 最后一个城市序号
int first_index = *arr; // 第一个城市序号
double last_dis = distance(city_pos[last_index-],city_pos[first_index-]);
path = path + last_dis;
return path; // 返回总的路径长度
} // 选择操作
void Choice(int chrom[sizepop][lenchrom])
{
double pick;
double choice_arr[sizepop][lenchrom];
double fit_pro[sizepop];
double sum = ;
double fit[sizepop]; // 适应度函数数组(距离的倒数)
for(int j=;j<sizepop;j++)
{
double path = path_len(chrom[j]);
double fitness = /path;
fit[j] = fitness;
sum += fitness;
}
for(int j=;j<sizepop;j++)
{
fit_pro[j] = fit[j]/sum; // 概率数组
}
// 开始轮盘赌
for(int i=;i<sizepop;i++)
{
pick = ((double)rand())/RAND_MAX; // 0到1之间的随机数
for(int j=;j<sizepop;j++)
{
pick = pick - fit_pro[j];
if(pick<=)
{
for(int k=;k<lenchrom;k++)
choice_arr[i][k] = chrom[j][k]; // 选中一个个体
break;
}
} }
for(int i=;i<sizepop;i++)
{
for(int j=;j<lenchrom;j++)
chrom[i][j] = choice_arr[i][j];
}
} //交叉操作
void Cross(int chrom[sizepop][lenchrom])
{
double pick;
double pick1,pick2;
int choice1,choice2;
int pos1,pos2;
int temp;
int conflict1[lenchrom]; // 冲突位置
int conflict2[lenchrom];
int num1,num2;
int index1,index2;
int move = ; // 当前移动的位置
while(move<lenchrom-)
{
pick = ((double)rand())/RAND_MAX; // 用于决定是否进行交叉操作
if(pick > pcross)
{
move += ;
continue; // 本次不进行交叉
}
// 采用部分映射杂交
choice1 = move; // 用于选取杂交的两个父代
choice2 = move+; // 注意避免下标越界
pick1 = ((double)rand())/(RAND_MAX+1.0);
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom); // 用于确定两个杂交点的位置
pos2 = (int)(pick2*lenchrom);
while(pos1 > lenchrom - || pos1 < )
{
pick1 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom);
}
while(pos2 > lenchrom - || pos2 < )
{
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos2 = (int)(pick2*lenchrom);
}
if(pos1 > pos2)
{
temp = pos1;
pos1 = pos2;
pos2 = temp; // 交换pos1和pos2的位置
}
for(int j=pos1;j<=pos2;j++)
{
temp = chrom[choice1][j];
chrom[choice1][j] = chrom[choice2][j];
chrom[choice2][j] = temp; // 逐个交换顺序
}
num1 = ;
num2 = ;
if(pos1 > && pos2 < lenchrom-)
{
for(int j =;j<=pos1-;j++)
{
for(int k=pos1;k<=pos2;k++)
{
if(chrom[choice1][j] == chrom[choice1][k])
{
conflict1[num1] = j;
num1++;
}
if(chrom[choice2][j] == chrom[choice2][k])
{
conflict2[num2] = j;
num2++;
}
}
}
for(int j=pos2+;j<lenchrom;j++)
{
for(int k=pos1;k<=pos2;k++)
{
if(chrom[choice1][j] == chrom[choice1][k])
{
conflict1[num1] = j;
num1++;
}
if(chrom[choice2][j] == chrom[choice2][k])
{
conflict2[num2] = j;
num2++;
}
} }
}
if((num1 == num2) && num1 > )
{
for(int j=;j<num1;j++)
{
index1 = conflict1[j];
index2 = conflict2[j];
temp = chrom[choice1][index1]; // 交换冲突的位置
chrom[choice1][index1] = chrom[choice2][index2];
chrom[choice2][index2] = temp;
}
}
move += ;
}
} // 变异操作
// 变异策略采取随机选取两个点，将其对换位置
void Mutation(int chrom[sizepop][lenchrom])
{
double pick,pick1,pick2;
int pos1,pos2,temp;
for(int i=;i<sizepop;i++)
{
pick = ((double)rand())/RAND_MAX; // 用于判断是否进行变异操作
if(pick > pmutation)
continue;
pick1 = ((double)rand())/(RAND_MAX+1.0);
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom); // 选取进行变异的位置
pos2 = (int)(pick2*lenchrom);
while(pos1 > lenchrom-)
{
pick1 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom);
}
while(pos2 > lenchrom-)
{
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos2 = (int)(pick2*lenchrom);
}
temp = chrom[i][pos1];
chrom[i][pos1] = chrom[i][pos2];
chrom[i][pos2] = temp;
}
} // 进化逆转操作
void Reverse(int chrom[sizepop][lenchrom])
{
double pick1,pick2;
double dis,reverse_dis;
int n;
int flag,pos1,pos2,temp;
int reverse_arr[lenchrom]; for(int i=;i<sizepop;i++)
{
flag = ; // 用于控制本次逆转是否有效
while(flag == )
{
pick1 = ((double)rand())/(RAND_MAX+1.0);
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom); // 选取进行逆转操作的位置
pos2 = (int)(pick2*lenchrom);
while(pos1 > lenchrom-)
{
pick1 = ((double)rand())/(RAND_MAX+1.0);
pos1 = (int)(pick1*lenchrom);
}
while(pos2 > lenchrom -)
{
pick2 = ((double)rand())/(RAND_MAX+1.0);
pos2 = (int)(pick2*lenchrom);
}
if(pos1 > pos2)
{
temp = pos1;
pos1 = pos2;
pos2 = temp; // 交换使得pos1 <= pos2
}
if(pos1 < pos2)
{
for(int j=;j<lenchrom;j++)
reverse_arr[j] = chrom[i][j]; // 复制数组
n = ; // 逆转数目
for(int j=pos1;j<=pos2;j++)
{
reverse_arr[j] = chrom[i][pos2-n]; // 逆转数组
n++;
}
reverse_dis = path_len(reverse_arr); // 逆转之后的距离
dis = path_len(chrom[i]); // 原始距离
if(reverse_dis < dis)
{
for(int j=;j<lenchrom;j++)
chrom[i][j] = reverse_arr[j]; // 更新个体
}
}
flag = ;
} }
} // 主函数
int main(void)
{
time_t start,finish;
start = clock(); // 开始计时
srand((unsigned)time(NULL)); // 初始化随机数种子
init(); // 初始化种群 int best_fit_index = ; //最短路径出现代数
double distance_arr[sizepop];
double dis;
for(int j=;j<sizepop;j++)
{
dis = path_len(chrom[j]);
distance_arr[j] = dis;
}
double * best_index = min(distance_arr); // 计算最短路径及序号
min_distance = *(best_index+); // 最短路径
int index = (int)(*best_index); // 最短路径序号
for(int j=;j<lenchrom;j++)
best_result[j] = chrom[index][j]; // 最短路径序列 // 开始进化
double * new_arr;
double new_min_dis;
int new_index;
for(int i=;i<maxgen;i++)
{
Choice(chrom); // 选择
Cross(chrom); //交叉
Mutation(chrom); //变异
Reverse(chrom); // 逆转操作
for(int j=;j<sizepop;j++)
distance_arr[j] = path_len(chrom[j]); // 距离数组
new_arr = min(distance_arr);
new_min_dis = *(new_arr+); //新的最短路径
if(new_min_dis < min_distance)
{
min_distance = new_min_dis; // 更新最短路径
new_index =(int)(*new_arr);
for(int j=;j<lenchrom;j++)
best_result[j] = chrom[new_index][j]; // 更新最短路径序列
best_fit_index = i+; // 最短路径代数
}
}
finish = clock(); // 计算结束
double duration = ((double)(finish-start))/CLOCKS_PER_SEC; // 计算耗时
printf("本程序使用遗传算法求解规模为%d的TSP问题,种群数目为:%d,进化代数为:%d\n",lenchrom,sizepop,maxgen);
printf("得到最短路径为:%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d-->%d\n",best_result[],best_result[],best_result[],
best_result[],best_result[],best_result[],best_result[],best_result[],best_result[],best_result[],best_result[],best_result[],
best_result[],best_result[]);
printf("最短路径长度为:%lf,得到最短路径在第%d代.\n",min_distance,best_fit_index);
printf("程序耗时:%lf秒.\n",duration);
return ;
}
这里取种群数目为100，最大进化代数为200，在ubuntu16.04下使用gcc编译器得到结果如下：
经过多次求解发现，在到了一定代数之后最优解保持不变，而且多次求解得到的最优路径相同，可以认为求得了问题的实际最优解。但是这里城市个数只有14个，属于规模较小的TSP问题，我决定再将问题规模变大来测试遗传算法优化的性能。这里选用规模为31的中国TSP问题，首先保持种群数目和进化代数不变，得到结果如下：
可以发现遗传算法得到的最短路径大概为16136.633514,而已知的中国TSP问题的最优解为15377，还是有一定的差距，并且算法有的时候收敛过早，陷入了局部最优解，并且稳定性较差，每次运行得到的结果波动较大。为了解决这个问题，我们决定将种群数目和进化代数增大，种群数目变为500，进化代数变为1000，重新运行程序得到的结果如下：
多次运行程序给出的最优解相近，波动很小，其中最好的一次为上图中的15380.515324,与真实最优解15377十分接近，这说明在增大种群规模以及进化代数之后遗传算法的优化能力又得到了进一步地提高，而且不易陷入局部最优解，总是能找到接近最优解的次优解，这也充分说明了遗传算法对于求解TSP问题还是十分有效的，也说明了遗传算法的普适性。
当然，遗传算法也有其局限性，比如对于大规模的寻优问题容易早熟，陷入局部最优等等，如果有机会我后面还会再补充这方面的内容，以及遗传算法在其他领域的应用。
遗传算法的C语言实现(二)-----以求解TSP问题为例的更多相关文章
- 遗传算法的C语言实现(二)
上一次我们使用遗传算法求解了一个较为复杂的多元非线性函数的极值问题,也基本了解了遗传算法的实现基本步骤.这一次,我再以经典的TSP问题为例,更加深入地说明遗传算法中选择.交叉.变异等核心步骤的实现.而 ...
- 模拟退火算法（SA）求解TSP 问题（C语言实现）
这篇文章是之前写的智能算法(遗传算法(GA).粒子群算法(PSO))的补充.其实代码我老早之前就写完了,今天恰好重新翻到了,就拿出来给大家分享一下,也当是回顾与总结了. 首先介绍一下模拟退火算法(SA ...
- 利用遗传算法求解TSP问题
转载地址 https://blog.csdn.net/greedystar/article/details/80343841 目录 一.问题描述 二.算法描述 三.求解说明 四.参考资料 五.源代码 ...
- 使用C语言实现二维,三维绘图算法(1)-透视投影
使用C语言实现二维,三维绘图算法(1)-透视投影 ---- 引言---- 每次使用OpenGL或DirectX写三维程序的时候, 都有一种隔靴搔痒的感觉, 对于内部的三维算法的实现不甚了解. 其实想想 ...
- 使用C语言实现二维,三维绘图算法(3)-简单的二维分形
使用C语言实现二维,三维绘图算法(3)-简单的二维分形 ---- 引言---- 每次使用OpenGL或DirectX写三维程序的时候, 都有一种隔靴搔痒的感觉, 对于内部的三维算法的实现不甚了解. 其 ...
- 使用C语言实现二维,三维绘图算法(2)-解析曲面的显示
使用C语言实现二维,三维绘图算法(2)-解析曲面的显示 ---- 引言---- 每次使用OpenGL或DirectX写三维程序的时候, 都有一种隔靴搔痒的感觉, 对于内部的三维算法的实现不甚了解. 其 ...
- Swift语言指南(二)--语言基础之注释和分号
原文:Swift语言指南(二)--语言基础之注释和分号 注释 通过注释向自己的代码中注入不可执行的文本,作为你自己的笔记或提示.Swift编译器运行时会忽略注释. Swift的注释与C语言极其相似,单 ...
- 文本主题模型之LDA(二) LDA求解之Gibbs采样算法
文本主题模型之LDA(一) LDA基础 文本主题模型之LDA(二) LDA求解之Gibbs采样算法 文本主题模型之LDA(三) LDA求解之变分推断EM算法(TODO) 本文是LDA主题模型的第二篇, ...
- #r语言（二）笔记
#r语言(二)笔记 #早复习 #概述:R是用于统计分析.绘图的语言和操作环境 #对象: #数据类型--统称为对象 #向量(vector):用于存储数值型.字符型或逻辑型数据的一维数组. #定义向量: ...
随机推荐
- 结合个人经历总结的前端入门方法 (转自https://github.com/qiu-deqing/FE-learning)
结合个人经历总结的前端入门方法 (https://github.com/qiu-deqing/FE-learning),里面有很详细的介绍. 之前一直想学习前端的,都不知道怎么下手都一年了啥也没学到, ...
- VPN安装后报错：Reason442 & Error56
VPN安装后一直报错,同样的32位安装包别人安装是正常,自己安装就不正常了,考虑到是自己电脑配置的问题. 经过一番努力,解决了问题,下面就本次解决过程做一个小小的总结. (1)确保VPN Servic ...
- 版本控制简介，git使用----使用GitHub托管代码
关于版本控制: 很久以前,人们苦于对写过的代码进行版本的管理,经常过了一段时间想恢复原来写过的代码却又忘了不知道丢到哪儿去了,有的人用加上时间后缀来命名文件的方法,便于后期维护,但是这样做的麻烦也很大 ...
- jQuery 绑定事件
$('input').bind('click mouseover', fn); $('input').bind({ mouseover: fn(){}, mouseover:fn(){} }); 删除 ...
- .net下开发ActiveX控件
` ActiveX 是一个开放的集成平台,为开发人员. 用户和 Web生产商提供了一个快速而简便的在 Internet 和 Intranet 创建程序集成和内容的方法. 使用 ActiveX, 可 ...
- lamp遇到问题
1.配置好apache和虚拟host,显示无权, 将网站目录更新755,还是不行,最后selinux: 1.设置下面即可: chcon -R -h -t httpd_sys_content_t /ho ...
- Win10
安装 调优 关闭cortana 对于SSD: 关闭windows search , superfetch服务,减少磁盘读写 关闭动画(个性化里面) 开启项优化 休眠文件(powercfg -h off ...
- 转: Hibernate commit() 和flush() 的区别
[java] view plaincopyprint? <<精通Hibernate java对象持久化技术详解>> ,flush()方法进行清理缓存的操作,执行一系列的SQL语 ...
- sfliter__except_handler4
sfliter源码在vs08中编译 出现 错误error LNK2019: unresolved external symbol __except_handler4 referenced in fun ...
- 驱动插ring3线程执行代码
近日有在写一个小东西 需要在内核态中运行一个WIN32程序 之前提到的插入APC可以满足部分要求 但是一到WIN7 x86平台下就崩溃了WIN7下只能插入第三方的进程 一插入系统进程就崩溃,但是这样满 ...