dic算法

Ⅰ 用python实现红酒数据集的ID3,C4.5和CART算法

ID3算法介绍
ID3算法全称为迭代二叉树3代算法（Iterative Dichotomiser 3）
该算法要先进行特征选择，再生成决策树，其中特征选择是基于“信息增益”最大的原则进行的。
但由于决策树完全基于训练集生成的，有可能对训练集过于“依赖”，即产生过拟合现象。因此在生成决策树后，需要对决策树进行剪枝。剪枝有两种形式，分别为前剪枝（Pre-Pruning）和后剪枝（Post-Pruning），一般采用后剪枝。
信息熵、条件熵和信息增益
信息熵：来自于香农定理，表示信息集合所含信息的平均不确定性。信息熵越大，表示不确定性越大，所含的信息量也就越大。
设x 1 , x 2 , x 3 , . . . x n {x_1, x_2, x_3, ...x_n}x
1

,x
2

,x
3

,...x
n

为信息集合X的n个取值，则x i x_ix
i

的概率：
P ( X = i ) = p i , i = 1 , 2 , 3 , . . . , n P(X=i) = p_i, i=1,2,3,...,n
P(X=i)=p
i

,i=1,2,3,...,n

信息集合X的信息熵为：
H ( X ) = − ∑ i = 1 n p i log ⁡ p i H(X) =- \sum_{i=1}^{n}{p_i}\log{p_i}
H(X)=−
i=1
∑
n

p
i

logp
i

条件熵：指已知某个随机变量的情况下，信息集合的信息熵。
设信息集合X中有y 1 , y 2 , y 3 , . . . y m {y_1, y_2, y_3, ...y_m}y
1

,y
2

,y
3

,...y
m

组成的随机变量集合Y，则随机变量（X，Y）的联合概率分布为
P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}
P(x=i,y=j)=p
ij

条件熵：
H ( X ∣ Y ) = ∑ j = 1 m p ( y j ) H ( X ∣ y j ) H(X|Y) = \sum_{j=1}^m{p(y_j)H(X|y_j)}
H(X∣Y)=
j=1
∑
m

p(y
j

)H(X∣y
j

)
由
H ( X ∣ y j ) = − ∑ j = 1 m p ( y j ) ∑ i = 1 n p ( x i ∣ y j ) log ⁡ p ( x i ∣ y j ) H(X|y_j) = - \sum_{j=1}^m{p(y_j)}\sum_{i=1}^n{p(x_i|y_j)}\log{p(x_i|y_j)}
H(X∣y
j

)=−
j=1
∑
m

p(y
j

)
i=1
∑
n

p(x
i

∣y
j

)logp(x
i

∣y
j

)
和贝叶斯公式：
p ( x i y j ) = p ( x i ∣ y j ) p ( y j ) p(x_iy_j) = p(x_i|y_j)p(y_j)
p(x
i

y
j

)=p(x
i

∣y
j

)p(y
j

)
可以化简条件熵的计算公式为:
H ( X ∣ Y ) = ∑ j = 1 m ∑ i = 1 n p ( x i , y j ) log ⁡ p ( x i ) p ( x i , y j ) H(X|Y) = \sum_{j=1}^m \sum_{i=1}^n{p(x_i, y_j)\log\frac{p(x_i)}{p(x_i, y_j)}}
H(X∣Y)=
j=1
∑
m

i=1
∑
n

p(x
i

,y
j

)log
p(x
i

,y
j

)
p(x
i

)

信息增益：信息熵-条件熵，用于衡量在知道已知随机变量后，信息不确定性减小越大。
d ( X , Y ) = H ( X ) − H ( X ∣ Y ) d(X,Y) = H(X) - H(X|Y)
d(X,Y)=H(X)−H(X∣Y)

python代码实现
import numpy as np
import math

def calShannonEnt(dataSet):
""" 计算信息熵 """
labelCountDict = {}
for d in dataSet:
label = d[-1]
if label not in labelCountDict.keys():
labelCountDict[label] = 1
else:
labelCountDict[label] += 1
entropy = 0.0
for l, c in labelCountDict.items():
p = 1.0 * c / len(dataSet)
entropy -= p * math.log(p, 2)
return entropy

def filterSubDataSet(dataSet, colIndex, value):
"""返回colIndex特征列label等于value，并且过滤掉改特征列的数据集"""
subDataSetList = []
for r in dataSet:
if r[colIndex] == value:
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
subDataSetList.append(newR)
return np.array(subDataSetList)

def chooseFeature(dataSet):
""" 通过计算信息增益选择最合适的特征"""
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)
bestInfoGain = 0.0
bestFeatureIndex = -1
for i in range(featureNum):
uniqueValues = np.unique(dataSet[:, i])
condition_entropy = 0.0

for v in uniqueValues: #计算条件熵
subDataSet = filterSubDataSet(dataSet, i, v)
p = 1.0 * len(subDataSet) / len(dataSet)
condition_entropy += p * calShannonEnt(subDataSet)
infoGain = entropy - condition_entropy #计算信息增益

if infoGain >= bestInfoGain: #选择最大信息增益
bestInfoGain = infoGain
bestFeatureIndex = i
return bestFeatureIndex

def creatDecisionTree(dataSet, featNames):
""" 通过训练集生成决策树 """
featureName = featNames[:] # 拷贝featNames，此处不能直接用赋值操作，否则新变量会指向旧变量的地址
classList = list(dataSet[:, -1])
if len(set(classList)) == 1: # 只有一个类别
return classList[0]
if dataSet.shape[1] == 1: #当所有特征属性都利用完仍然无法判断样本属于哪一类，此时归为该数据集中数量最多的那一类
return max(set(classList), key=classList.count)

bestFeatureIndex = chooseFeature(dataSet) #选择特征
bestFeatureName = featNames[bestFeatureIndex]
del featureName[bestFeatureIndex] #移除已选特征列
decisionTree = {bestFeatureName: {}}

featureValueUnique = sorted(set(dataSet[:, bestFeatureIndex])) #已选特征列所包含的类别， 通过递归生成决策树
for v in featureValueUnique:
FeatureName = featureName[:]
subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)
decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, FeatureName)
return decisionTree

def classify(decisionTree, featnames, featList):
""" 使用训练所得的决策树进行分类 """
classLabel = None
root = decisionTree.keys()[0]
firstGenDict = decisionTree[root]
featIndex = featnames.index(root)
for k in firstGenDict.keys():
if featList[featIndex] == k:
if isinstance(firstGenDict[k], dict): #若子节点仍是树，则递归查找
classLabel = classify(firstGenDict[k], featnames, featList)
else:
classLabel = firstGenDict[k]
return classLabel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
下面用鸢尾花数据集对该算法进行测试。由于ID3算法只能用于标称型数据，因此用在对连续型的数值数据上时，还需要对数据进行离散化，离散化的方法稍后说明，此处为了简化，先使用每一种特征所有连续性数值的中值作为分界点，小于中值的标记为1，大于中值的标记为0。训练1000次，统计准确率均值。

from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
data = np.c_[iris.data, iris.target]

scoreL = []
for i in range(1000): #对该过程进行10000次
trainData, testData = train_test_split(data) #区分测试集和训练集

featNames = iris.feature_names[:]
for i in range(trainData.shape[1] - 1): #对训练集每个特征，以中值为分界点进行离散化
splitPoint = np.mean(trainData[:, i])
featNames[i] = featNames[i]+'<='+'{:.3f}'.format(splitPoint)
trainData[:, i] = [1 if x <= splitPoint else 0 for x in trainData[:, i]]
testData[:, i] = [1 if x <= splitPoint else 0 for x in testData[:, i]]

decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))
print 'score: ', np.mean(scoreL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
输出结果为：score: 0.7335，即准确率有73%。每次训练和预测的准确率分布如下：

数据离散化
然而，在上例中对特征值离散化的划分点实际上过于“野蛮”，此处介绍一种通过信息增益最大的标准来对数据进行离散化。原理很简单，当信息增益最大时，说明用该点划分能最大程度降低数据集的不确定性。
具体步骤如下：

对每个特征所包含的数值型特征值排序
对相邻两个特征值取均值，这些均值就是待选的划分点
用每一个待选点把该特征的特征值划分成两类，小于该特征点置为1， 大于该特征点置为0，计算此时的条件熵，并计算出信息增益
选择信息使信息增益最大的划分点进行特征离散化
实现代码如下：

def filterRawData(dataSet, colIndex, value, tag):
""" 用于把每个特征的连续值按照区分点分成两类，加入tag参数，可用于标记筛选的是哪一部分数据"""
filterDataList = []
for r in dataSet:
if (tag and r[colIndex] <= value) or ((not tag) and r[colIndex] > value):
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
filterDataList.append(newR)
return np.array(filterDataList)

def dataDiscretization(dataSet, featName):
""" 对数据每个特征的数值型特征值进行离散化 """
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)

for featIndex in range(featureNum): #对于每一个特征
uniqueValues = sorted(np.unique(dataSet[:, featIndex]))
meanPoint = []

for i in range(len(uniqueValues) - 1): # 求出相邻两个值的平均值
meanPoint.append(float(uniqueValues[i+1] + uniqueValues[i]) / 2.0)
bestInfoGain = 0.0
bestMeanPoint = -1
for mp in meanPoint: #对于每个划分点
subEntropy = 0.0 #计算该划分点的信息熵
for tag in range(2): #分别划分为两类
subDataSet = filterRawData(dataSet, featIndex, mp, tag)
p = 1.0 * len(subDataSet) / len(dataSet)
subEntropy += p * calShannonEnt(subDataSet)

## 计算信息增益
infoGain = entropy - subEntropy
## 选择最大信息增益
if infoGain >= bestInfoGain:
bestInfoGain = infoGain
bestMeanPoint = mp
featName[featIndex] = featName[featIndex] + "<=" + "{:.3f}".format(bestMeanPoint)
dataSet[:, featIndex] = [1 if x <= bestMeanPoint else 0 for x in dataSet[:, featIndex]]
return dataSet, featName
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
重新对数据进行离散化，并重复该步骤1000次，同时用sklearn中的DecisionTreeClassifier对相同数据进行分类，分别统计平均准确率。运行代码如下:

from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
scoreL = []
scoreL_sk = []
for i in range(1000): #对该过程进行1000次
featNames = iris.feature_names[:]
trainData, testData = train_test_split(data) #区分测试集和训练集
trainData_tmp = .(trainData)
testData_tmp = .(testData)
discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根据信息增益离散化
for i in range(testData.shape[1]-1): #根据测试集的区分点离散化训练集
splitPoint = float(discritizationFeatName[i].split('<=')[-1])
testData[:, i] = [1 if x<=splitPoint else 0 for x in testData[:, i]]
decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

clf = DecisionTreeClassifier('entropy')
clf.fit(trainData[:, :-1], trainData[:, -1])
clf.predict(testData[:, :-1])
scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))

print 'score: ', np.mean(scoreL)
print 'score-sk: ', np.mean(scoreL_sk)
fig = plt.figure(figsize=(10, 4))
plt.subplot(1,2,1)
pd.Series(scoreL).hist(grid=False, bins=10)
plt.subplot(1,2,2)
pd.Series(scoreL_sk).hist(grid=False, bins=10)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
两者准确率分别为：
score: 0.7037894736842105
score-sk: 0.7044736842105263

准确率分布如下：

两者的结果非常一样。
（但是。。为什么根据信息熵离散化得到的准确率比直接用均值离散化的准确率还要低啊？？哇的哭出声。。）

最后一次决策树图形如下：

决策树剪枝
由于决策树是完全依照训练集生成的，有可能会有过拟合现象，因此一般会对生成的决策树进行剪枝。常用的是通过决策树损失函数剪枝，决策树损失函数表示为:
C a ( T ) = ∑ t = 1 T N t H t ( T ) + α ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|
C
a

(T)=
t=1
∑
T

N
t

H
t

(T)+α∣T∣

其中，H t ( T ) H_t(T)H
t

(T)表示叶子节点t的熵值，T表示决策树的深度。前项∑ t = 1 T N t H t ( T ) \sum_{t=1}^TN_tH_t(T)∑
t=1
T

N
t

H
t

(T)是决策树的经验损失函数当随着T的增加，该节点被不停的划分的时候，熵值可以达到最小，然而T的增加会使后项的值增大。决策树损失函数要做的就是在两者之间进行平衡，使得该值最小。
对于决策树损失函数的理解，如何理解决策树的损失函数? - 陶轻松的回答 - 知乎这个回答写得挺好，可以按照答主的思路理解一下

C4.5算法
ID3算法通过信息增益来进行特征选择会有一个比较明显的缺点：即在选择的过程中该算法会优先选择类别较多的属性（这些属性的不确定性小，条件熵小，因此信息增益会大），另外，ID3算法无法解决当每个特征属性中每个分类都只有一个样本的情况（此时每个属性的条件熵都为0）。
C4.5算法ID3算法的改进，它不是依据信息增益进行特征选择，而是依据信息增益率，它添加了特征分裂信息作为惩罚项。定义分裂信息：
S p l i t I n f o ( X , Y ) = − ∑ i n ∣ X i ∣ ∣ X ∣ log ⁡ ∣ X i ∣ ∣ X ∣ SplitInfo(X, Y) =-\sum_i^n\frac{|X_i|}{|X|}\log\frac{|X_i|}{|X|}
SplitInfo(X,Y)=−
i
∑
n

∣X∣
∣X
i

∣

log
∣X∣
∣X
i

∣

则信息增益率为：
G a i n R a t i o ( X , Y ) = d ( X , Y ) S p l i t I n f o ( X , Y ) GainRatio(X,Y)=\frac{d(X,Y)}{SplitInfo(X, Y)}
GainRatio(X,Y)=
SplitInfo(X,Y)
d(X,Y)

关于ID3和C4.5算法
在学习分类回归决策树算法时，看了不少的资料和博客。关于这两个算法，ID3算法是最早的分类算法，这个算法刚出生的时候其实带有很多缺陷：

无法处理连续性特征数据
特征选取会倾向于分类较多的特征
没有解决过拟合的问题
没有解决缺失值的问题
即该算法出生时是没有带有连续特征离散化、剪枝等步骤的。C4.5作为ID3的改进版本弥补列ID3算法不少的缺陷：

通过信息最大增益的标准离散化连续的特征数据
在选择特征是标准从“最大信息增益”改为“最大信息增益率”
通过加入正则项系数对决策树进行剪枝
对缺失值的处理体现在两个方面：特征选择和生成决策树。初始条件下对每个样本的权重置为1。
特征选择：在选取最优特征时，计算出每个特征的信息增益后，需要乘以一个**“非缺失值样本权重占总样本权重的比例”**作为系数来对比每个特征信息增益的大小
生成决策树：在生成决策树时，对于缺失的样本我们按照一定比例把它归属到每个特征值中，比例为该特征每一个特征值占非缺失数据的比重
关于C4.5和CART回归树
作为ID3的改进版本，C4.5克服了许多缺陷，但是它自身还是存在不少问题：

C4.5的熵运算中涉及了对数运算，在数据量大的时候效率非常低。
C4.5的剪枝过于简单
C4.5只能用于分类运算不能用于回归
当特征有多个特征值是C4.5生成多叉树会使树的深度加深
————————————————
版权声明：本文为CSDN博主“Sarah Huang”的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44794704/article/details/89406612

Ⅱ C#中怎么在字符串中查询子串的个数

static int Count(string WithinString, string search)
{
if (string.IsNullOrEmpty(search))
throw new ArgumentNullException("search");
int counter = 0;
int index = WithinString.IndexOf(search,0);
while(index >=0 && index < WithinString.Length)
{
counter++;
index = WithinString.IndexOf(search,index+search.Length);
}
return counter;
}
//这是一个方核裂法，尘氏搏WithinString字符串，search你想查看个数的字符派祥串，counter返回个数

Ⅲ java中文分词组件word怎么使用

参考如下
1、快速体验
运行项目根目录下的脚本demo-word.bat可以快速体验分词效果
用法: command [text] [input] [output]
命令command的可选值为：demo、text、file
demo
text 杨尚川是APDPlat应用级产品开发平台的作者
file d:/text.txt d:/word.txt
exit

2、对文本进行分词
移除停用词：List<Word> words = WordSegmenter.seg("杨尚川是APDPlat应用级产品开发平台的作者");
保留停用词：List<Word> words = WordSegmenter.segWithStopWords("杨尚川是APDPlat应用级产品开发平台的作者");
System.out.println(words);

输出：
移除停用词：[杨尚川, apdplat, 应用级, 产品, 开发平台, 作者]
保留停用词：[杨尚川, 是, apdplat, 应用级, 产品, 开发平台, 的, 作者]

3、对文件进行分词
String input = "d:/text.txt";
String output = "d:/word.txt";
移除停用词：WordSegmenter.seg(new File(input), new File(output));
保留停用词：WordSegmenter.segWithStopWords(new File(input), new File(output));

4、自定义配置文件
默认配置文件为类路径下的word.conf，打包在word-x.x.jar中
自定义配置文件为类路径下的word.local.conf，需要用户自己提供
如果自定义配置和默认配置相同，自定义配置会覆盖默认配置
配置文件编码为UTF-8

5、自定义用户词库
自定义用户词库为一个或多个文件夹或文件，可以使用绝对路径或相对路径
用户词库由多个词典文件组成，文件编码为UTF-8
词典文件的格式为文本文件，一行代表一个词
可以通过系统属性或配置文件的方式来指定路径，多个路径之间用逗号分隔开
类路径下的词典文件，需要在相对路径前加入前缀classpath:

指定方式有三种：
指定方式一，编程指定（高优先级）：
WordConfTools.set("dic.path", "classpath:dic.txt，d:/custom_dic");
DictionaryFactory.reload();//更改词典路径之后，重新加载词典
指定方式二，Java虚拟机启动参数（中优先级）：
java -Ddic.path=classpath:dic.txt，d:/custom_dic
指定方式三，配置文件指定（低优先级）：
使用类路径下的文件word.local.conf来指定配置信息
dic.path=classpath:dic.txt，d:/custom_dic

如未指定，则默认使用类路径下的dic.txt词典文件

6、自定义停用词词库
使用方式和自定义用户词库类似，配置项为：
stopwords.path=classpath:stopwords.txt，d:/custom_stopwords_dic

7、自动检测词库变化
可以自动检测自定义用户词库和自定义停用词词库的变化
包含类路径下的文件和文件夹、非类路径下的绝对路径和相对路径
如：
classpath:dic.txt，classpath:custom_dic_dir,
d:/dic_more.txt，d:/DIC_DIR，D:/DIC2_DIR，my_dic_dir，my_dic_file.txt

classpath:stopwords.txt，classpath:custom_stopwords_dic_dir，
d:/stopwords_more.txt，d:/STOPWORDS_DIR，d:/STOPWORDS2_DIR，stopwords_dir，remove.txt

8、显式指定分词算法
对文本进行分词时，可显式指定特定的分词算法，如：
WordSegmenter.seg("APDPlat应用级产品开发平台", SegmentationAlgorithm.BidirectionalMaximumMatching);

SegmentationAlgorithm的可选类型为：
正向最大匹配算法：MaximumMatching
逆向最大匹配算法：ReverseMaximumMatching
正向最小匹配算法：MinimumMatching
逆向最小匹配算法：ReverseMinimumMatching
双向最大匹配算法：BidirectionalMaximumMatching
双向最小匹配算法：BidirectionalMinimumMatching
双向最大最小匹配算法：
全切分算法：FullSegmentation
最少分词算法：MinimalWordCount
最大Ngram分值算法：MaxNgramScore

9、分词效果评估
运行项目根目录下的脚本evaluation.bat可以对分词效果进行评估
评估采用的测试文本有253 3709行，共2837 4490个字符
评估结果位于target/evaluation目录下：
corpus-text.txt为分好词的人工标注文本，词之间以空格分隔
test-text.txt为测试文本，是把corpus-text.txt以标点符号分隔为多行的结果
standard-text.txt为测试文本对应的人工标注文本，作为分词是否正确的标准
result-text-***.txt，***为各种分词算法名称，这是word分词结果
perfect-result-***.txt，***为各种分词算法名称，这是分词结果和人工标注标准完全一致的文本
wrong-result-***.txt，***为各种分词算法名称，这是分词结果和人工标注标准不一致的文本

Ⅳ 智能算法有哪些

（1）人工神经网络（Artificial Neural Network）类：反向传播（Backpropagation）、波尔兹曼机（Boltzmann Machine）、卷积神经网络（Convolutional Neural Network）、Hopfield网络（hopfield Network）、多层感知器（Multilyer Perceptron）、径向基函数网络（Radial Basis Function Network，RBFN）、受限波尔兹曼机（Restricted Boltzmann Machine）、回归神经网络（Recurrent Neural Network，RNN）、自组织映射（Self-organizing Map，SOM）、尖峰神经网络（Spiking Neural Network）等。
（2）贝叶斯类（Bayesin）：朴素贝叶斯（Naive Bayes）、高斯贝叶斯（Gaussian Naive Bayes）、多项朴素贝叶斯（Multinomial Naive Bayes）、平均-依赖性评估（Averaged One-Dependence Estimators，AODE）
贝叶斯信念网络（Bayesian Belief Network，BBN）、贝叶斯网络（Bayesian Network，BN）等。
（3）决策树（Decision Tree）类：分类和回归树（Classification and Regression Tree，CART）、迭代Dichotomiser3（Iterative Dichotomiser 3， ID3）,C4.5算法（C4.5 Algorithm）、C5.0算法（C5.0 Algorithm）、卡方自动交互检测（Chi-squared Automatic Interaction Detection，CHAID）、决策残端（Decision Stump）、ID3算法（ID3 Algorithm）、随机森林（Random Forest）、SLIQ（Supervised Learning in Quest）等。
（4）线性分类器（Linear Classifier）类：Fisher的线性判别（Fisher’s Linear Discriminant）
线性回归（Linear Regression）、逻辑回归（Logistic Regression）、多项逻辑回归（Multionmial Logistic Regression）、朴素贝叶斯分类器（Naive Bayes Classifier）、感知（Perception）、支持向量机（Support Vector Machine）等。
常见的无监督学习类算法包括：
（1） 人工神经网络（Artificial Neural Network）类：生成对抗网络（Generative Adversarial Networks，GAN），前馈神经网络（Feedforward Neural Network）、逻辑学习机（Logic Learning Machine）、自组织映射（Self-organizing Map）等。
（2） 关联规则学习（Association Rule Learning）类：先验算法（Apriori Algorithm）、Eclat算法（Eclat Algorithm）、FP-Growth算法等。
（3）分层聚类算法（Hierarchical Clustering）：单连锁聚类（Single-linkage Clustering），概念聚类（Conceptual Clustering）等。
（4）聚类分析（Cluster analysis）：BIRCH算法、DBSCAN算法，期望最大化（Expectation-maximization，EM）、模糊聚类（Fuzzy Clustering）、K-means算法、K均值聚类（K-means Clustering）、K-medians聚类、均值漂移算法（Mean-shift）、OPTICS算法等。

Ⅳ 如何对excel表格里的词结巴分词python

#-*-coding:utf-8-*-
importjieba
'''''
Createdon2015-11-23
'''

defword_split(text):
"""
Splitatextinwords.
(word,location).
"""
word_list=[]
windex=0
word_primitive=jieba.cut(text,cut_all=True)
forwordinword_primitive:
iflen(word)>0:
word_list.append((windex,word))
windex+=1
returnword_list

definverted_index(text):
"""
CreateanInverted-.
{word:[locations]}
"""
inverted={}
forindex,wordinword_split(text):
locations=inverted.setdefault(word,[])
locations.append(index)
returninverted


definverted_index_add(inverted,doc_id,doc_index):
"""
AddInvertd-Indexdoc_indexofthedocumentdoc_idtothe
Multi-DocumentInverted-Index(inverted),
usingdoc_idasdocumentidentifier.
{word:{doc_id:[locations]}}
"""
forword,locationsindoc_index.iteritems():
indices=inverted.setdefault(word,{})
indices[doc_id]=locations
returninverted

defsearch_a_word(inverted,word):
"""
searchoneword
"""
word=word.decode('utf-8')
ifwordnotininverted:
returnNone
else:
word_index=inverted[word]
returnword_index

defsearch_words(inverted,wordList):
"""
searchmorethanoneword
"""
wordDic=[]
docRight=[]
forwordinwordList:
ifisinstance(word,str):
word=word.decode('utf-8')
ifwordnotininverted:
returnNone
else:
element=inverted[word].keys()
element.sort()
wordDic.append(element)
numbers=len(wordDic)
inerIndex=[0foriinrange(numbers)]
docIndex=[wordDic[i][0]foriinrange(numbers)]
flag=True
whileflag:
ifmin(docIndex)==max(docIndex):
docRight.append(min(docIndex))
inerIndex=[inerIndex[i]+1foriinrange(numbers)]
foriinrange(numbers):
ifinerIndex[i]>=len(wordDic[i]):
flag=False
returndocRight
docIndex=[wordDic[i][inerIndex[i]]foriinrange(numbers)]
else:
minIndex=min(docIndex)
minPosition=docIndex.index(minIndex)
inerIndex[minPosition]+=1
ifinerIndex[minPosition]>=len(wordDic[minPosition]):
flag=False
returndocRight
docIndex=[wordDic[i][inerIndex[i]]foriinrange(numbers)]

defsearch_phrase(inverted,phrase):
"""
searchphrase
"""
docRight={}
temp=word_split(phrase)
wordList=[temp[i][1]foriinrange(len(temp))]
docPossible=search_words(inverted,wordList)
fordocindocPossible:
wordIndex=[]
indexRight=[]
forwordinwordList:
wordIndex.append(inverted[word][doc])
numbers=len(wordList)
inerIndex=[0foriinrange(numbers)]
words=[wordIndex[i][0]foriinrange(numbers)]
flag=True
whileflag:
ifwords[-1]-words[0]==numbers-1:
indexRight.append(words[0])
inerIndex=[inerIndex[i]+1foriinrange(numbers)]
foriinrange(numbers):
ifinerIndex[i]>=len(wordIndex[i]):
flag=False
docRight[doc]=indexRight
break
ifflag:
words=[wordIndex[i][inerIndex[i]]foriinrange(numbers)]
else:
minIndex=min(words)
minPosition=words.index(minIndex)
inerIndex[minPosition]+=1
ifinerIndex[minPosition]>=len(wordIndex[minPosition]):
flag=False
break
ifflag:
words=[wordIndex[i][inerIndex[i]]foriinrange(numbers)]
returndocRight


if__name__=='__main__':
doc1="""
中文分词指的是将一个汉字序列切分成一个一个单独的词。分词就是将连续的字序列按照一定的规范
重新组合成词序列的过程。我们知道，在英文的行文中，单词之间是以空格作为自然分界符的，而中文
只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，虽然英文也同样
存在短语的划分问题，不过在词这一层上，中文比之英文要复杂的多、困难的多。
"""

doc2="""
存在中文分词技术，是由于中文在基本文法上有其特殊性，具体表现在：
与英文为代表的拉丁语系语言相比，英文以空格作为天然的分隔符，而中文由于继承自古代汉语的传统，
词语之间没有分隔。古代汉语中除了连绵词和人名地名等，词通常就是单个汉字，所以当时没有分词
书写的必要。而现代汉语中双字或多字词居多，一个字不再等同于一个词。
在中文里，“词”和“词组”边界模糊
现代汉语的基本表达单元虽然为“词”，且以双字或者多字词居多，但由于人们认识水平的不同，对词和
短语的边界很难去区分。
例如：“对随地吐痰者给予处罚”，“随地吐痰者”本身是一个词还是一个短语，不同的人会有不同的标准，
同样的“海上”“酒厂”等等，即使是同一个人也可能做出不同判断，如果汉语真的要分词书写，必然会出现
混乱，难度很大。
中文分词的方法其实不局限于中文应用，也被应用到英文处理，如手写识别，单词之间的空格就不很清楚，
中文分词方法可以帮助判别英文单词的边界。
"""

doc3="""
作用
中文分词是文本挖掘的基础，对于输入的一段中文，成功的进行中文分词，可以达到电脑自动识别语句含义的效果。
中文分词技术属于自然语言处理技术范畴，对于一句话，人可以通过自己的知识来明白哪些是词，哪些不是词，
但如何让计算机也能理解？其处理过程就是分词算法。
影响
中文分词对于搜索引擎来说，最重要的并不是找到所有结果，因为在上百亿的网页中找到所有结果没有太多的意义，
没有人能看得完，最重要的是把最相关的结果排在最前面，这也称为相关度排序。中文分词的准确与否，常常直接
影响到对搜索结果的相关度排序。从定性分析来说，搜索引擎的分词算法不同，词库的不同都会影响页面的返回结果
"""

doc4="""
这种方法又叫做机械分词方法，它是按照一定的策略将待分析的汉字串与一个“充分大的”机器词典中的词条进行配，
若在词典中找到某个字符串，则匹配成功（识别出一个词）。按照扫描方向的不同，串匹配分词方法可以分为正向
匹配和逆向匹配；按照不同长度优先匹配的情况，可以分为最大（最长）匹配和最小（最短）匹配；常用的几种
机械分词方法如下：
正向最大匹配法（由左到右的方向）；
逆向最大匹配法（由右到左的方向）；
最少切分（使每一句中切出的词数最小）；
双向最大匹配法（进行由左到右、由右到左两次扫描）
还可以将上述各种方法相互组合，例如，可以将正向最大匹配方法和逆向最大匹配方法结合起来构成双向匹配法。
由于汉语单字成词的特点，正向最小匹配和逆向最小匹配一般很少使用。一般说来，逆向匹配的切分精度略高于
正向匹配，遇到的歧义现象也较少。统计结果表明，单纯使用正向最大匹配的错误率为，单纯使用逆向
最大匹配的错误率为。但这种精度还远远不能满足实际的需要。实际使用的分词系统，都是把机械分词
作为一种初分手段，还需通过利用各种其它的语言信息来进一步提高切分的准确率。
一种方法是改进扫描方式，称为特征扫描或标志切分，优先在待分析字符串中识别和切分出一些带有明显特征
的词，以这些词作为断点，可将原字符串分为较小的串再来进机械分词，从而减少匹配的错误率。另一种方法
是将分词和词类标注结合起来，利用丰富的词类信息对分词决策提供帮助，并且在标注过程中又反过来对分词
结果进行检验、调整，从而极大地提高切分的准确率。
对于机械分词方法，可以建立一个一般的模型，在这方面有专业的学术论文，这里不做详细论述。
"""

doc5="""
从形式上看，词是稳定的字的组合，因此在上下文中，相邻的字同时出现的次数越多，就越有可能构成一个词。
因此字与字相邻共现的频率或概率能够较好的反映成词的可信度。可以对语料中相邻共现的各个字的组合的频度
进行统计，计算它们的互现信息。定义两个字的互现信息，计算两个汉字的相邻共现概率。互现信息体现了
汉字之间结合关系的紧密程度。当紧密程度高于某一个阈值时，便可认为此字组可能构成了一个词。这种方法
只需对语料中的字组频度进行统计，不需要切分词典，因而又叫做无词典分词法或统计取词方法。但这种方法
也有一定的局限性，会经常抽出一些共现频度高、但并不是词的常用字组，例如“这一”、“之一”、“有的”、
“我的”、“许多的”等，并且对常用词的识别精度差，时空开销大。实际应用的统计分词系统都要使用一部基本
的分词词典（常用词词典）进行串匹配分词，同时使用统计方法识别一些新的词，即将串频统计和串匹配结合起来，
既发挥匹配分词切分速度快、效率高的特点，又利用了无词典分词结合上下文识别生词、自动消除歧义的优点。
另外一类是基于统计机器学习的方法。首先给出大量已经分词的文本，利用统计机器学习模型学习词语切分的规律
（称为训练），从而实现对未知文本的切分。我们知道，汉语中各个字单独作词语的能力是不同的，此外有的字常
常作为前缀出现，有的字却常常作为后缀（“者”“性”），结合两个字相临时是否成词的信息，这样就得到了许多
与分词有关的知识。这种方法就是充分利用汉语组词的规律来分词。这种方法的最大缺点是需要有大量预先分好词
的语料作支撑，而且训练过程中时空开销极大。
到底哪种分词算法的准确度更高，目前并无定论。对于任何一个成熟的分词系统来说，不可能单独依靠某一种算法
来实现，都需要综合不同的算法。例如，海量科技的分词算法就采用“复方分词法”，所谓复方，就是像中西医结合
般综合运用机械方法和知识方法。对于成熟的中文分词系统，需要多种算法综合处理问题。
"""

#BuildInverted-Indexfordocuments
inverted={}
documents={'doc1':doc1,'doc2':doc2,'doc3':doc3,'doc4':doc4,'doc5':doc5}
fordoc_id,textindocuments.iteritems():
doc_index=inverted_index(text)
inverted_index_add(inverted,doc_id,doc_index)

#Searchoneword
aWord="分词"
result_a_word=search_a_word(inverted,aWord)
ifresult_a_word:
result_a_word_docs=result_a_word.keys()
print"'%s'isappearedat"%(aWord)
forresult_a_word_docinresult_a_word_docs:
result_a_word_index=result_a_word[result_a_word_doc]
forindexinresult_a_word_index:
print(str(index)+''),
print"of"+result_a_word_doc
print""
else:
print"Nomatches!
"

#Searchmorethanoneword
words=["汉语","切分"]
result_words=search_words(inverted,words)
ifresult_words:
print("["),
foriinrange(len(words)):
print("%s"%(words[i])),
print("]areappearedatthe"),
forresult_words_docinresult_words:
print(result_words_doc+''),
print"
"
else:
print"Nomatches!
"

#Searchphrase
phrase="中文分词"
result_phrase=search_phrase(inverted,phrase)
ifresult_phrase:
result_phrase_docs=result_phrase.keys()
print"'%s'isappearedatthe"%(phrase)
forresult_phrase_docinresult_phrase_docs:
result_phrase_index=result_phrase[result_phrase_doc]
forindexinresult_phrase_index:
print(str(index)+''),
print"of"+result_phrase_doc
print""
else:
print"Nomatches!
"

Ⅵ 签名算法怎么来的

数字签名算法分析与Hash签名

序：这篇文章我用了近一周的时间完成，其中涉及到的RSA算法已经在上一篇《公钥密码体系》中详细的介绍过，目前数字签名中人们使用很多的还是512位与1024位的RSA算法。


摘要： 数字签字和认证机构是电子商务的核心技术。数字签名作为目前Internet中电子商务重要的技术，不断地进行改进，标准化。本文从数字签名的意义出发，详细介绍了数字签名中涉及到的内容与算法，并自行结合进行改进。

关键词：Internet公钥加密 Hash函数 电子商务加密数字签名

数字签名简介

我们对加解密算法已经有了一定理解,可以进一步讨论"数字签名"（注意不要与数字认证混淆）的问题了,即如何给一个计算机文件进行签字。数字签字可以用对称算法实现，也可以用公钥算法实现。但前者除了文件签字者和文件接受者双方，还需要第三方认证，较麻烦；通过公钥加密算法的实现方法，由于用秘密密钥加密的文件，需要靠公开密钥来解密，因此这可以作为数字签名，签名者用秘密密钥加密一个签名（可以包括姓名、证件号码、短信息等信息），接收人可以用公开的、自己的公开密钥来解密，如果成功，就能确保信息来自该公开密钥的所有人。

公钥密码体制实现数字签名的基本原理很简单，假设A要发送一个电子文件给B，A、B双方只需经过下面三个步骤即可：

1． A用其私钥加密文件，这便是签字过程

2． A将加密的文件送到B

3． B用A的公钥解开A送来的文件

这样的签名方法是符合可靠性原则的。即：

签字是可以被确认的，
签字是无法被伪造的，
签字是无法重复使用的，
文件被签字以后是无法被篡改的，
签字具有无可否认性，
数字签名就是通过一个单向函数对要传送的报文进行处理得到的用以认证报文来源并核实报文是否发生变化的一个字母数字串。用这几个字符串来代替书写签名或印章，起到与书写签名或印章同样的法律效用。国际社会已开始制定相应的法律、法规，把数字签名作为执法的依据。

数字签名的实现方法

实现数字签名有很多方法，目前数字签名采用较多的是公钥加密技术，如基于RSA Data Security公司的PKCS（Public Key Cryptography Standards）、DSA（Digital Signature Algorithm）、x.509、PGP（Pretty Good Privacy）。1994年美国标准与技术协会公布了数字签名标准（DSS）而使公钥加密技术广泛应用。同时应用散列算法（Hash）也是实现数字签名的一种方法。

非对称密钥密码算法进行数字签名

算法的含义：

非对称密钥密码算法使用两个密钥：公开密钥和私有密钥，分别用于对数据的加密和解密，即如果用公开密钥对数据进行加密，只有用对应的私有密钥才能进行解密；如果用私有密钥对数据进行加密，则只有用对应的公开密钥才能解密。

使用公钥密码算法进行数字签名通用的加密标准有： RSA，DSA，Diffie－Hellman等。

签名和验证过程：

发送方（甲）首先用公开的单向函数对报文进行一次变换，得到数字签名，然后利用私有密钥对数字签名进行加密后附在报文之后一同发出。

接收方（乙）用发送方的公开密钥对数字签名进行解密交换，得到一个数字签名的明文。发送方的公钥可以由一个可信赖的技术管理机构即认证中心（CA）发布的。

接收方将得到的明文通过单向函数进行计算，同样得到一个数字签名，再将两个数字签名进行对比，如果相同，则证明签名有效，否则无效。

这种方法使任何拥有发送方公开密钥的人都可以验证数字签名的正确性。由于发送方私有密钥的保密性，使得接受方既可以根据结果来拒收该报文，也能使其无法伪造报文签名及对报文进行修改，原因是数字签名是对整个报文进行的，是一组代表报文特征的定长代码，同一个人对不同的报文将产生不同的数字签名。这就解决了银行通过网络传送一张支票，而接收方可能对支票数额进行改动的问题，也避免了发送方逃避责任的可能性。

对称密钥密码算法进行数字签名

算法含义

对称密钥密码算法所用的加密密钥和解密密钥通常是相同的，即使不同也可以很容易地由其中的任意一个推导出另一个。在此算法中，加、解密双方所用的密钥都要保守秘密。由于计算机速度而广泛应用于大量数据如文件的加密过程中，如RD4和DES，用IDEA作数字签名是不提倡的。

使用分组密码算法数字签名通用的加密标准有：DES，Tripl－DES,RC2,RC4,CAST等。

签名和验证过程

Lamport发明了称为Lamport-Diffle的对称算法：利用一组长度是报文的比特数（n）两倍的密钥A，来产生对签名的验证信息，即随机选择2n个数B，由签名密钥对这2n个数B进行一次加密交换，得到另一组2n个数C。

发送方从报文分组M的第一位开始，依次检查M的第I位，若为0时，取密钥A的第i位，若为1则取密钥A的第i+1位；直至报文全部检查完毕。所选取的n个密钥位形成了最后的签名。

接受方对签名进行验证时，也是首先从第一位开始依次检查报文M，如果M的第i位为0时，它就认为签名中的第i组信息是密钥A的第i位，若为1则为密钥A的第i+1位；直至报文全部验证完毕后，就得到了n个密钥，由于接受方具有发送方的验证信息C，所以可以利用得到的n个密钥检验验证信息，从而确认报文是否是由发送方所发送。

这种方法由于它是逐位进行签名的，只有有一位被改动过，接受方就得不到正确的数字签名，因此其安全性较好，其缺点是：签名太长（对报文先进行压缩再签名，可以减少签名的长度）；签名密钥及相应的验证信息不能重复使用，否则极不安全。

结合对称与非对称算法的改进

对称算法与非对称算法各有利弊，所以结合各自的优缺点进行改进，可以用下面的模块进行说明：

Hash算法进行数字签名

Hash算法也称作散列算法或报文摘要，Hash算法将在数字签名算法中详细说明。

Hash算法数字签字通用的加密标准有： SHA－1，MD5等。

数字签名算法

数字签名的算法很多,应用最为广泛的三种是: Hash签名、DSS签名、RSA签名。这三种算法可单独使用，也可综合在一起使用。数字签名是通过密码算法对数据进行加、解密变换实现的，常用的HASH算法有MD2、MD5、SHA-1，用DES算法、RSA算法都可实现数字签名。但或多或少都有缺陷，或者没有成熟的标准。

Hash签名

Hash签名是最主要的数字签名方法，也称之为数字摘要法（digital digest）、数字指纹法（digital finger print）。它与RSA数字签名是单独的签名不同，该数字签名方法是将数字签名与要发送的信息紧密联系在一起，它更适合于电子商务活动。将一个商务合同的个体内容与签名结合在一起，比合同和签名分开传递，更增加了可信度和安全性。下面我们将详细介绍Hash签名中的函数与算法。

Ⅶ python对数据进行聚类怎么显示数据分类

将其整理成数据集为：
[ [1,0,"yes"],[1,1,"yes"],[0,1,"yes"],[0,0,"no"],[1,0,"no"] ]
算法过程：

1、计算原始的信息熵。
2、依次计算数据集中每个样本的每个特征的信息熵。
3、比较不同特征信息熵的大小，选出信息熵最大的特征值并输出。
运行结果：
col : 0 curInfoGain : 2.37744375108 baseInfoGain : 0.0
col : 1 curInfoGain : 1.37744375108 baseInfoGain : 2.37744375108
bestInfoGain : 2.37744375108 bestFeature: 0
结果分析：
说明按照第一列，即有无喉结这个特征来进行分类的效果更好。
思考：
1、能否利用决策树算法，将样本最终的分类结果进行输出？如样本1,2,3属于男性，4属于女性。

2、示例程序生成的决策树只有一层，当特征量增多的时候，如何生成具有多层结构的决策树？
3、如何评判分类结果的好坏？
在下一篇文章中，我将主要对以上三个问题进行分析和解答。如果您也感兴趣，欢迎您订阅我的文章，也可以在下方进行评论，如果有疑问或认为不对的地方，您也可以留言，我将积极与您进行解答。
完整代码如下：
from math import log
"""
计算信息熵
"""
def calcEntropy(dataset):
diclabel = {} ## 标签字典，用于记录每个分类标签出现的次数
for record in dataset:
label = record[-1]
if label not in diclabel.keys():
diclabel[label] = 0
diclabel[label] += 1
### 计算熵
entropy = 0.0
cnt = len(dataset)
for label in diclabel.keys():
prob = float(1.0 * diclabel[label]/cnt)
entropy -= prob * log(prob,2)
return entropy
def initDataSet():
dataset = [[1,0,"yes"],[1,1,"yes"],[0,1,"yes"],[0,0,"no"],[1,0,"no"]]
label = ["male","female"]
return dataset,label
#### 拆分dataset ,根据指定的过滤选项值，去掉指定的列形成一个新的数据集
def splitDataset(dataset , col, value):
retset = [] ## 拆分后的数据集
for record in dataset:
if record[col] == value :
recedFeatVec = record[:col]
recedFeatVec.extend(record[col+1:]) ### 将指定的列剔除
retset.append(recedFeatVec) ### 将新形成的特征值列表追加到返回的列表中
return retset
### 找出信息熵增益最大的特征值
### 参数：
### dataset : 原始的数据集
def findBestFeature(dataset):
numFeatures = len(dataset[0]) - 1 ### 特征值的个数
baseEntropy = calcEntropy(dataset) ### 计算原始数据集的熵
baseInfoGain = 0.0 ### 初始信息增益
bestFeature = -1 ### 初始的最优分类特征值索引
### 计算每个特征值的熵
for col in range(numFeatures):
features = [record[col] for record in dataset] ### 提取每一列的特征向量 如此处col= 0 ，则features = [1,1,0,0]
uniqueFeat = set(features)
curInfoGain = 0 ### 根据每一列进行拆分，所获得的信息增益
for featVal in uniqueFeat:
subDataset = splitDataset(dataset,col,featVal) ### 根据col列的featVal特征值来对数据集进行划分
prob = 1.0 * len(subDataset)/numFeatures ### 计算子特征数据集所占比例
curInfoGain += prob * calcEntropy(subDataset) ### 计算col列的特征值featVal所产生的信息增益
# print "col : " ,col , " featVal : " , featVal , " curInfoGain :" ,curInfoGain ," baseInfoGain : " ,baseInfoGain
print "col : " ,col , " curInfoGain :" ,curInfoGain ," baseInfoGain : " ,baseInfoGain
if curInfoGain > baseInfoGain:
baseInfoGain = curInfoGain
bestFeature = col
return baseInfoGain,bestFeature ### 输出最大的信息增益，以获得该增益的列
dataset,label = initDataSet()
infogain , bestFeature = findBestFeature(dataset)
print "bestInfoGain :" , infogain, " bestFeature:",bestFeature

Ⅷ 〔C++算法分析〕迷宫问题

在还没学习bfs的情况下做到一个迷宫问题，于是的大概了解了一下DFS和BFS，就以本题为例子讲一下我初识的bfs

/*

试题 : 迷宫

本题总分：15 分

【问题描述】

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍旁握纤，标记为 0 的为可 以通行的地方。

010000

000100

001001

110000

迷宫皮渗的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫，一运仿共10步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。

对于下面这个更复杂的迷宫（30 行50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。

在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）





























































【答案提交】

       这是一道结果填空的题，你只需要算出结果后提交即可。

       本题的结果为一个字符串，包含四种字母 D、U、L、R，

       在提交答案时只填写这个字符串，填写多余的内容将无法得分。

*/

#include

#include

#include

using namespace std;

const int N                  = 30;

const int M                  =50;                                                       //数据范围

const int fx[4][2]   = { 1, 0, 0, -1, 0, 1, -1, 0 };           //方向向量，直接按字典序排列

const char     dic[5]             = "DLRU";                                                //字典序

char maze[N+5][M+5]; //地图

char path[N+5][M+5]; //上一步的方向

void bfs()

{

       queue > q;

       q.push(make_pair(1,1));

       maze[1][1]= '1';

       while(!q.empty())

       {

              intx = q.front().first;

              inty = q.front().second;

              q.pop();

              for(int i = 0; i < 4; i++)

              {

                     intxx = x + fx[i][0];

                     intyy = y + fx[i][1];

                     if(maze[xx][yy] == '0')

                     {

                            maze[xx][yy]= '1';

                            q.push(make_pair(xx,yy));

                            path[xx][yy]= i;

                     }

              }

       }

}

void print(int x, int y)

{

       if(x != 1 || y != 1)

       {

              intt = path[x][y];

              print(x- fx[t][0], y - fx[t][1]);

              maze[x][y]= 1;      //将走过的地方置1

              cout<< dic[t];

       }

}

int main()

{

       freopen("text.ini","r", stdin);

       memset(maze,'1', sizeof maze); //加围墙

       for(int i = 1; i <= N; i++)

              cin>> maze[i]+1;

       bfs();

       memset(maze,0, sizeof maze);   //初始化，0为墙，1为路径

       maze[1][1]= 1;

       print(N,M);    //输出最短路径字符，同时标记路径为1

       //输出迷宫图

       cout<< endl;

       for(int i = 0; i <= N + 1; i++)

       {

              for(int j = 0; j <= M + 1; j++)

              {

                     if(i == 0 || i == N + 1 || j == 0 || j == M + 1) cout << "※";    //画围墙

                     elseif (maze[i][j] == 0) cout << "■"; //迷宫里的墙

                     elsecout << "□"; //最短路的路径

              }

              cout<< endl;

       }

       cout<< "\nover" << endl;

       while(1);

       return0;

}

事例中，我们先将整个maze数组铺满全部范围，来建立墙，然后再对maze数组赋值，来建立迷宫，从而达到，墙裹着迷宫的效果。

然后我们建立一个名为q的queue来保存我们现在所在的位置。

数组fx代表方向，dic代表方向的字符。

数组path记录上一步的方向

寻路部分

首先将起点放入queue中，取得点之后，让起点出队，在吧起点堵死成墙。

然后从起点获得的值去同时向外延伸，遇到墙不延伸，死路表示这条线终结，没次延伸后，都把原来的点设置成墙。

在延伸的过程中，没到一个点便堵死成墙，并且出队，这样防止一个点多重赋值。

因为是对目前队列里所有的点同时延伸（虽然有先后顺序，但是总会延伸完这一阶段的点才会延伸下一阶段的点），所以不必担心走那条路会早一点到某一点，因为完到的，已经被堵死了。

在将所有起点能到达的点延伸完毕之后，队列为空，进行结算。

如果起点能达到终点的话，终点的path必定有值，只需要在终点倒推即可得到答案。

画图部分

先把全体设置成墙，再按照path倒推，结果是路程全被筛选出来。

by：有我wa

Ⅸ dic应变测量常用的行业有哪些

XTDIC主要应用在：汽车制造、航空航天、3C电子、岩煤土木、生物医学、材料研究

Ⅹ C#List中相同元素合并算法问题

List<int>list=newList<int>(){2,3,4,5,3,5,4,2,2,4,3};
varresult1渣嫌=fromiinlistgroupibyi;
varresult2=fromj洞磨inresult1纳梁斗selectj.Key*j.Count();
list=result2.ToList();

附加一个连接

http://www.cnblogs.com/zwq194/archive/2010/08/17/1801411.html