图算法安全边

⑴ 图算法怎么做啊

查看数据结构的书吧

⑵ [图像算法]-Faster RCNN详解

paper： Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
Tensorflow-faster r-cnn github: Tensorflow Faster RCNN for Object Detection

faster rcnn是何凯明等大神在2015年提出目标检测算法，该算法在2015年的ILSVRV和COCO竞赛中获得多项第一。该算法在fast rcnn基础上提出了RPN候选框生成算法，使得目标检测速度大大提高。

(1)image input；
(2)利用selective search 算法在图像中从上到下提取2000个左右的Region Proposal；
(3)将每个Region Proposal缩放(warp)成227*227的大小并输入到CNN，将CNN的fc7层的输出作为特征；
(4)将每个Region Proposal提取的CNN特征输入到SVM进行分类；
(5)对于SVM分好类的Region Proposal做边框回归，用Bounding box回归值校正原来的建议窗口，生成预测窗口坐标.
缺陷:
(1) 训练分为多个阶段，步骤繁琐：微调网络+训练SVM+训练边框回归器；
(2) 训练耗时，占用磁盘空间大；5000张图像产生几百G的特征文件；
(3) 速度慢：使用GPU，VGG16模型处理一张图像需要47s；
(4) 测试速度慢：每个候选区域需要运行整个前向CNN计算；
(5) SVM和回归是事后操作，在SVM和回归过程中CNN特征没有被学习更新.

(1)image input；
(2)利用selective search 算法在图像中从上到下提取2000个左右的建议窗口(Region Proposal)；
(3)将整张图片输入CNN，进行特征提取；
(4)把建议窗口映射到CNN的最后一层卷积feature map上；
(5)通过RoI pooling层使每个建议窗口生成固定尺寸的feature map；
(6)利用Softmax Loss(探测分类概率) 和Smooth L1 Loss(探测边框回归)对分类概率和边框回归(Bounding box regression)联合训练.

相比R-CNN，主要两处不同:
(1)最后一层卷积层后加了一个ROI pooling layer；
(2)损失函数使用了多任务损失函数(multi-task loss)，将边框回归直接加入到CNN网络中训练
改进:
(1) 测试时速度慢：R-CNN把一张图像分解成大量的建议框，每个建议框拉伸形成的图像都会单独通过CNN提取特征.实际上这些建议框之间大量重叠，特征值之间完全可以共享，造成了运算能力的浪费.
FAST-RCNN将整张图像归一化后直接送入CNN，在最后的卷积层输出的feature map上，加入建议框信息，使得在此之前的CNN运算得以共享.
(2) 训练时速度慢：R-CNN在训练时，是在采用SVM分类之前，把通过CNN提取的特征存储在硬盘上.这种方法造成了训练性能低下，因为在硬盘上大量的读写数据会造成训练速度缓慢.
FAST-RCNN在训练时，只需要将一张图像送入网络，每张图像一次性地提取CNN特征和建议区域，训练数据在GPU内存里直接进Loss层，这样候选区域的前几层特征不需要再重复计算且不再需要把大量数据存储在硬盘上.
(3) 训练所需空间大：R-CNN中独立的SVM分类器和回归器需要大量特征作为训练样本，需要大量的硬盘空间.FAST-RCNN把类别判断和位置回归统一用深度网络实现，不再需要额外存储.
(4) 由于ROI pooling的提出，不需要再input进行Corp和wrap操作，避免像素的损失，巧妙解决了尺度缩放的问题.

(1)输入测试图像；
(2)将整张图片输入CNN，进行特征提取；
(3)用RPN先生成一堆Anchor box，对其进行裁剪过滤后通过softmax判断anchors属于前景(foreground)或者后景(background)，即是物体or不是物体，所以这是一个二分类；同时，另一分支bounding box regression修正anchor box，形成较精确的proposal（注：这里的较精确是相对于后面全连接层的再一次box regression而言）
(4)把建议窗口映射到CNN的最后一层卷积feature map上；
(5)通过RoI pooling层使每个RoI生成固定尺寸的feature map；
(6)利用Softmax Loss(探测分类概率) 和Smooth L1 Loss(探测边框回归)对分类概率和边框回归(Bounding box regression)联合训练.

相比FASTER-RCNN，主要两处不同:
(1)使用RPN(Region Proposal Network)代替原来的Selective Search方法产生建议窗口；
(2)产生建议窗口的CNN和目标检测的CNN共享

改进:
(1) 如何高效快速产生建议框？
FASTER-RCNN创造性地采用卷积网络自行产生建议框，并且和目标检测网络共享卷积网络，使得建议框数目从原有的约2000个减少为300个，且建议框的质量也有本质的提高.

从上面的三张图可以看出，Faster R CNN由下面几部分组成：
1.数据集，image input
2.卷积层CNN等基础网络，提取特征得到feature map
3-1.RPN层，再在经过卷积层提取到的feature map上用一个3x3的slide window，去遍历整个feature map,在遍历过程中每个window中心按rate，scale（1:2,1:1,2:1）生成9个anchors，然后再利用全连接对每个anchors做二分类（是前景还是背景）和初步bbox regression，最后输出比较精确的300个ROIs。
3-2.把经过卷积层feature map用ROI pooling固定全连接层的输入维度。
4.然后把经过RPN输出的rois映射到ROIpooling的feature map上进行bbox回归和分类。

SPP-Net是出自论文《Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition》
由于一般的网络结构中都伴随全连接层，全连接层的参数就和输入图像大小有关，因为它要把输入的所有像素点连接起来,需要指定输入层神经元个数和输出层神经元个数，所以需要规定输入的feature的大小。而SPP-NET正好解决了这个问题。

如果原图输入是224x224，对于conv5出来后的输出，是13x13x256的，可以理解成有256个这样的filter，每个filter对应一张13x13的activation map.如果像上图那样将activation map pooling成4x4 2x2 1x1三张子图，做max pooling后，出来的特征就是固定长度的(16+4+1)x256那么多的维度了.如果原图的输入不是224x224，出来的特征依然是(16+4+1)x256；直觉地说，可以理解成将原来固定大小为(3x3)窗口的pool5改成了自适应窗口大小，窗口的大小和activation map成比例，保证了经过pooling后出来的feature的长度是一致的.

总结而言，当网络输入的是一张任意大小的图片，这个时候我们可以一直进行卷积、池化，直到网络的倒数几层的时候，也就是我们即将与全连接层连接的时候，就要使用金字塔池化，使得任意大小的特征图都能够转换成固定大小的特征向量，这就是空间金字塔池化的意义（多尺度特征提取出固定大小的特征向量）。

ROI pooling layer实际上是SPP-NET的一个精简版，SPP-NET对每个proposal使用了不同大小的金字塔映射，而ROI pooling layer只需要下采样到一个7x7的特征图.对于VGG16网络conv5_3有512个特征图，这样所有region proposal对应了一个7*7*512维度的特征向量作为全连接层的输入.

为什么要pooling成7×7的尺度？是为了能够共享权重。Faster RCNN除了用到VGG前几层的卷积之外，最后的全连接层也可以继续利用。当所有的RoIs都被pooling成（512\×7\×7）的feature map后，将它reshape 成一个一维的向量，就可以利用VGG16预训练的权重，初始化前两层全连接.

那么经过何种变换才能从图11中的窗口P变为窗口呢？比较简单的思路就是：

注意：只有当Proposal和Ground Truth比较接近时（线性问题），我们才能将其作为训练样本训练我们的线性回归模型，否则会导致训练的回归模型不work（当Proposal跟GT离得较远，就是复杂的非线性问题了，此时用线性回归建模显然不合理）.这个也是G-CNN: an Iterative Grid Based Object Detector多次迭代实现目标准确定位的关键. 线性回归就是给定输入的特征向量X，学习一组参数W，使得经过线性回归后的值跟真实值Y(Ground Truth)非常接近.即.那么Bounding-box中我们的输入以及输出分别是什么呢？

如上图中标识：
① rpn_cls：60*40*512-d ⊕ 1*1*512*18 > 60*40*92 逐像素对其9个Anchor box进行二分类
② rpn_bbox：60*40*512-d ⊕ 1*1*512*36>60*40*9*4 逐像素得到其9个Anchor box四个坐标信息

逐像素对Anchors分类标记
① 去除掉超过1000*600这原图的边界的anchor box
② 如果anchor box与ground truth的IoU值最大，标记为正样本，label=1
③ 如果anchor box与ground truth的IoU>0.7，标记为正样本，label=1
④ 如果anchor box与ground truth的IoU<0.3，标记为负样本，label=0
剩下的既不是正样本也不是负样本，不用于最终训练，label=-1

逐像素Bbox回归纠正
除了对anchor box进行标记外，另一件事情就是计算anchor box与ground truth之间的偏移量
令：ground truth:标定的框也对应一个中心点位置坐标x ,y 和宽高w ,h
anchor box: 中心点位置坐标x_a,y_a和宽高w_a,h_a
所以，偏移量：
△x=(x -x_a)/w_a △y=(y -y_a)/h_a
△w=log(w /w_a) △h=log(h /h_a)
通过ground truth box与预测的anchor box之间的差异来进行学习，从而是RPN网络中的权重能够学习到预测box的能力

接着进一步对Anchors进行越界剔除和使用nms非最大值抑制，剔除掉重叠的框；比如，设定IoU为0.7的阈值，即仅保留覆盖率不超过0.7的局部最大分数的box（粗筛）。最后留下大约2000个anchor，然后再取前N个box（比如300个）；这样，进入到下一层ROI Pooling时region proposal大约只有300个。

参考文献：

⑶ 图像算法方向的划分

划分有：
图像加密，数字水印，图像去噪，图像分割，图像配准，图像恢复，图像溶合，图像拼贴，特征提取。

⑷ 农夫过河的图算法

#include<iostream>

using namespace std;

#define VertexNum 16 //最大顶点数

typedef struct // 图的顶点
{
int farmer; // 农夫
int wolf; // 狼
int sheep; // 羊
int veget; // 白菜
}Vertex;

typedef struct
{
int vertexNum; // 图的当前顶点数
Vertex vertex[VertexNum]; // 顶点向量（代表顶点）
bool Edge[VertexNum][VertexNum]; // 邻接矩阵. 用于存储图中的边，其矩阵元素个数取决于顶点个数，与边数无关
}AdjGraph; // 定义图的邻接矩阵存储结构

bool visited[VertexNum] = {false}; // 对已访问的顶点进行标记（图的遍历）
int retPath[VertexNum] = {-1}; // 保存DFS搜索到的路径，即与某顶点到下一顶点的路径

// 查找顶点（F，W，S，V）在顶点向量中的位置
int locate(AdjGraph *graph, int farmer, int wolf, int sheep, int veget)
{
// 从0开始查找
for (int i = 0; i < graph->vertexNum; i++)
{
if ( graph->vertex[i].farmer == farmer && graph->vertex[i].wolf == wolf
&& graph->vertex[i].sheep == sheep && graph->vertex[i].veget == veget )
{
return i; //返回当前位置
}
}

return -1; //没有找到此顶点
}

// 判断目前的（F，W，S，V）是否安全
bool isSafe(int farmer, int wolf, int sheep, int veget)
{
//当农夫与羊不在一起时，狼与羊或羊与白菜在一起是不安全的
if ( farmer != sheep && (wolf == sheep || sheep == veget) )
{
return false;
}
else
{
return true; // 安全返回true
}
}

// 判断状态i与状态j之间是否可转换
bool isConnect(AdjGraph *graph, int i, int j)
{
int k = 0;

if (graph->vertex[i].wolf != graph->vertex[j].wolf)
{
k++;
}

if (graph->vertex[i].sheep != graph->vertex[j].sheep)
{
k++;
}

if (graph->vertex[i].veget != graph->vertex[j].veget)
{
k++;
}

// 以上三个条件不同时满足两个且农夫状态改变时，返回真, 也即农夫每次只能带一件东西过桥
if (graph->vertex[i].farmer != graph->vertex[j].farmer && k <= 1)
{
return true;
}
else
{
return false;
}
}

// 创建连接图
void CreateG(AdjGraph *graph)
{
int i = 0;
int j = 0;

// 生成所有安全的图的顶点
for (int farmer = 0; farmer <= 1; farmer++)
{
for (int wolf = 0; wolf <= 1; wolf++)
{
for (int sheep = 0; sheep <= 1; sheep++)
{
for (int veget = 0; veget <= 1; veget++)
{
if (isSafe(farmer, wolf, sheep, veget))
{
graph->vertex[i].farmer = farmer;
graph->vertex[i].wolf = wolf;
graph->vertex[i].sheep = sheep;
graph->vertex[i].veget = veget;
i++;
}
}
}
}
}

// 邻接矩阵初始化即建立邻接矩阵
graph->vertexNum = i;
for (i = 0; i < graph->vertexNum; i++)
{
for (j = 0; j < graph->vertexNum; j++)
{
// 状态i与状态j之间可转化，初始化为1，否则为0
if (isConnect(graph, i, j))
{
graph->Edge[i][j] = graph->Edge[j][i] = true;
}
else
{
graph->Edge[i][j] = graph->Edge[j][i] = false;
}
}
}

return;
}

// 判断在河的那一边
char* judgement(int state)
{
return ( (0 == state) ? "左岸" : "右岸" );
}

// 输出从u到v的简单路径，即顶点序列中不重复出现的路径
void printPath(AdjGraph *graph, int start, int end)
{
int i = start;

cout << "farmer" << ", wolf" << ", sheep" << ", veget" << endl;

while (i != end)
{
cout << "(" << judgement(graph->vertex[i].farmer) << ", " << judgement(graph->vertex[i].wolf)
<< ", " << judgement(graph->vertex[i].sheep) << ", " << judgement(graph->vertex[i].veget) << ")";
cout << endl;

i = retPath[i];
}

cout << "(" << judgement(graph->vertex[i].farmer) << ", " << judgement(graph->vertex[i].wolf)
<< ", " << judgement(graph->vertex[i].sheep) << ", " << judgement(graph->vertex[i].veget) << ")";
cout << endl;
}

// 深度优先搜索从u到v的简单路径 //DFS--Depth First Search
void dfsPath(AdjGraph *graph, int start, int end)
{
int i = 0;
visited[start] = true; //标记已访问过的顶点

if (start == end)
{
return ;
}

for (i = 0; i < graph->vertexNum; i++)
{
if (graph->Edge[start][i] && !visited[i])
{
retPath[start] = i;
dfsPath(graph, i, end);
}
}
}

int main()
{
AdjGraph graph;
CreateG(&graph);

int start = locate(&graph, 0, 0, 0, 0);
int end = locate(&graph, 1, 1, 1, 1);
dfsPath(&graph, start, end);

if (visited[end]) // 有结果
{
printPath(&graph, start, end);
return 0;
}

return -1;
}

⑸ 关于C++图算法中的VISITED和UNVISITED的问题

一般是自定义的全局变量型标志数组（逻辑型或者数值型），每个元素代表图中的一个顶点，你当然也可以用局部变量来实现，只是算法参数可能需要增加一个了（比如深度优先）
除非那个图算法来源教科书或者资料中前面已经定义了

⑹ 数据结构中图算法都能解答生活中什么样的问题

直观点就是线路规划,流量分析之类的直观图结构问题.
广义来说很多包含关系对的逻辑结构都可以转化成图,比如匹配问题可以转化成二分图.

⑺ 图算法中权是什么

图算法中权的是一个有意义的量，可以是时间，长度，花费（代价）等

⑻ 求常用的图算法（C语言描述）

/*Bezier曲线的Casteljau算法*/

float decas(degree,codff,t)
float coeff[];
float t;
int degree;
{
int r,i;
float t1;
float codffa[10];
t1=1.0-t;
for(i=0;i<=degree;i++)
coeffa[i]=coeff[i];
for(r=1;r<degree;r++)
for(i=0;i<=degree-r;i++)
{
coeffa[i]=t1*coeffa[i]+t*coeffa[i+1];
}
return (coeffa[0]);
}

/*B样条曲线—deBoor分割算法*/

float deboor(degree,coeff,knot,u,i)
float coeff[],knot[];
float u;
int degree,i;
{
int k,j;
float t1,t2;
float coeffa[30];
for(j=i-degree+1;j<=i+1;j++)
coeffa[j]=coeff[j-i+degree-1];
for(k=1;i<=degree;k++)
forj=i+1;j>=i-degree+k+1;j--)
{
t1=(knot[j+degree-k]-u)/(knot[j+degree-k]-knot[j-1]);
t2=1.0-t1;
coeffa[j]=t1*coeffa[j-1]+t2*coeffa[j];
}
return (coeffa[i+1]);
}

/*Bezier曲线的Horner算法*/

float hornbez(degree,coeff,t)
int degree;
float coff[];
float t;
{
int i,n;
float fact,t1,aux;
t1=1.0-t;fact=1.0;n=1;
aux=coeff[0]*t1;

for(i=1;i<degree;i++)
{
face=fact*t;
n=n*(degree-i+1)/i;
aux=(aux+fact*n*coeff[i])*t1;
}
aux=aux+fact*t*codff[degree];
return aux;
}

⑼ 算法：C语言实现（图算法）里面深度和广度优先搜索的参数里都是在传入一条起始边而不是一个点，为什么

一般情况下，dfs和bfs都是传入点，然后从点扩展出去。
两个结构大概是这样的
void dfs(int u)
{
if (所有节点都遍历)
return;
找出所有与u相连的点v且还未被访问的节点
{
v置访问标记；
dfs(v);
}
}

void bfs()
{
根节点入队；
while (队列为空）
{
u = 队头节点出队；
找出所有与u相连的点v且还未被访问的节点
{
v置访问标记；
v入队；
}
}
}

⑽ 如何完全图生成最小二叉树

这种树成为带度限制条件的生成树。简称度限制生成树。求解方法我看了，但没看懂。给你直接粘过来太乱。神牛自己慢慢研究去吧。在google里网络一下就行^_^
这里是我帮你搜好的几个网址
http://hi..com/liveroom/blog/item/978e7d2305d2d4479358070f.html