全局图算法
① 求一个图的最大完全子图的算法
最大完全子图，超超的地址我打不开
用度的方法是不行的，因为完全子图可能每一个结点的度都不一样
我想能不能这样：
从某一个结点开始深度优先遍历，同时用一个路径数组记录下遍历走过的每一个结点，每进入遍历结点，先看看该结点的邻接点是否包含已知路径上的所有结点，若是，则把该结点加入路径数组，继续从新结点遍历；若不是，回溯到上一结点；这样直到无法回溯（另外设置一个访问状态数组VisitIN[]，起始结点的所有邻接点VisitIN值为1就无法回溯了）就找到一个完全子图
把起始结点访问状态Visit[]改为1，继续从下一结点出发重复上述过程，直到找到最大的完全子图。（算法的关键是判断某一结点的邻接点是否包含路径数组的所有结点）
不过这样做复杂度是高的了，我还没想到更好的方法。
各点度不一样不要紧，可以降低一级，再查。如下图中，最大度数为3，先找是否有另外3个3度点且都1-1相连，发现没有，就降为寻找有否3个2度点相互都1-1相连，这样就找到了。
2
*
/ \
/ \
*-----*----*----*
2 3 2 1
② 如何证明dijkstra 算法是全局最优算法
证明：
（I）首先考虑最简单的情况，找找思路。
由于现在只知道S到S的最短距离，也就是0，所以第一步只能考虑从S出发直接到达各点的距离(显然在这个时候考虑路径存在中间顶点没有意义，因为你不能确定S到这个中间顶点的最短路径)。得到S直达各点的w(S,V_i)，i=1,2,...,n-1，与w[0,i]比较，w[1,i]保存小值。
这个时候，Dijkstra的做法是选出所有d[0,i]，i=0...n-1，为false的对应的w[1,i]，i=0...n-1，中的最小值w[1,k]并认为这就是源点S到目标顶点V_k的最短距离。这很好理解，因为假设S到V_k的最短距离是另外一条路径，则必然存在一个中间顶点，不妨设为V_u，u=0...n-1，则有w(S,V_u) + w(V_u, V_k) < w(S,V_k)，那么必有w(S,V_u) < w(S,V_k)，显然，这与w[1,k]是最小值矛盾，所以w[1,k]就是S到V_k的最短距离，此时把d[1,k]标记为true。
算法的中间值如何得出：
其实以上的叙述已经说明了中间值是如何得到的。设w[x,y]是当前刚确定的源点S到目标定点V_y的最短距离，其中x=0...n-1，y=0...n-1，对所有d[x,i]，i=0...n-1，为false的点，更新w[x+1,i]为w[x,i]与(w[x,y]+w(V_y,V_i))的较小值。（I）里的w[x,y]就是w[0,0]。
（II）现在考虑一般情况
设已求得一个集合A，|A|=k，现在求S到第(k+1)个点(注意不一定是V_(k+1)，这里的k只是A的基数而已)。
设w[k-1,u]，u=0...n-1，是在集合A的基数为k时，所有未访问的w[k-1,i]，i=0...n-1，保存的中间值中的最小值(也就是最后一个纳入集合A的顶点，k-1-0+1=k)。标记d[k-1,u]为true，对所有w[k,i]，更新d[k-1,i]为false的w[k,i]的值，使其为w[k-1,i]与w[k-1,u]+w(V_u, V_i)的较小值，然后选出d[k,i]为false的所有w[k,i]的最小值w[k,p]，p=0...n-1，即源点S到目标顶点p的最短距离，标记d[k,p]为true，继续这一过程，直到某一次求出的最小值为int.MaxValue(表示之后的点都不能到达)。
道理仍然是一样的，如果这个最小值w[k,p]不是源点S到顶点V_p的最短距离，那么设S经过顶点V_t然后到达V_p(V_t是这条路径的倒数第二个顶点)。V_t存在两种可能，要么属于集合A但不是顶点V_u，要么属于集合B。
（i）如果V_t属于A但不是顶点V_u，由于每一个中间值在每求出一个最短距离时都是比较过的，也就是说，在求出S到V_t的最短距离时，S->V_t->V_p的长度必然是和原来的S->V_p的路径长度比较过的，一定会保存下来，则不可能得到当前这个w[k,p]，w[k,p]里保存的应该是S经过V_t到V_p的长度而不是S经过V_u到V_p的长度。
（ii）如果V_t属于B，不妨设这条路径为S->V_r->V_o->V_t->V_p，其中V_r属于A，V_o，V_t可以是同一点，也可以是不同点，但是他们都不属于A而是属于B，那么显然有S->V_r->V_o的长度小于S->V_r->V_o->V_t->V_p的长度小于w[k,p]，即w[k,o] < w[k,p]，与w[k,p]是最小值矛盾。
(iii) 如果路径为S->V_t->V_p且V_t属于B，那么显然S->V_t比S->V_p要近，也就是说，在选择下一个最小值的时候，应该选择w[s,t]而非w[s,p]。
所以，这样一个顶点V_t不存在，一般情况得证。
证毕。
③ 频率分布图算法
最大值减去最小值除以你想分的组数得到的是组距，然后在最小值上累加组距得到分组，数出在每个组距间的个数就可以了(用个数N除以总数*100％就是频率了。)
④ 最佳阀值分割 编程实现otsu最佳全局阀值算法
a=imread('YuChu.bmp');
如果读入的是彩色图，需要用a=rgb2gray(a);转换为灰度图
加了这句我运行了下，程序没出现错误也能出图
另外matlab图像处理工具箱中用level = graythresh(I)函数去阈值，其方法与你的方法一致，都是Otsu方法
补充：
你看看a读入时数据的大小，要是3维的话就是RGB图像了，需要转一下
另外是程序错误还是结果不对？
⑤ 图算法怎么做啊
查看数据结构的书吧
⑥ 图谱有哪些算法
图谱有哪些算法这是一个高性能的图形数据库，我之前也有介绍过。在此直接进行应用。之前我都是在Win10虚拟机中使用的，这里正好在安装的同时，也把步骤记录下来。
下载：https://neo4j.com/download/neo4j-desktop/?edition=desktop&flavour=osx&release=1.1.15&offline=true
正常操作后，可以启动管理界面。
Neo4j分为桌面版和社区版，个人比较偏向于桌面版，容易管理：
SDK安装：
Python API安装：
(base) zhanglipengdeMacBook-Pro:~ zhanglipeng$ sudo pip install neo4j-driver
Password:
DEPRECATION: Python 2.7 will reach the end of its life on January 1st, 2020. Please upgrade your Python as Python 2.7 won't be maintained after that date. A future version of pip will drop support for Python 2.7.
The directory '/Users/zhanglipeng/Library/Caches/pip/http' or its parent directory is not owned by the current user and the cache has been disabled. Please check the permissions and owner of that directory. If executing pip with sudo, you may want sudo's -H flag.
The directory '/Users/zhanglipeng/Library/Caches/pip' or its parent directory is not owned by the current user and caching wheels has been disabled. check the perm six
⑦ 全局优化算法是怎样分类的
最早对全局优化方法作出分类的是Leon[12]｡他根据搜索技术的不同
⑧ 全局路径规划算法
全局路径规划，主要算法有
1、网格法、
2、拓扑法、
3、视图法。
⑨ 什么是多序列全局比对的累进算法（三个步骤）
第一，所有的序列之间逐一比对（双重比对）；第二，生成一个系统树图，将序列按相似性大致分组；第三，使用系统树图作为引导，产生出最终的多序列比对结果。
⑩ 图的所有生成树的算法
边构成,并包含G的所有顶点的树称为G的生成树(G连通).
加权无向图G的生成树的代价是该生成树的所有边的代码(权)的和.
最小代价生成树是其所有生成树中代价最小的生成树.
参考代码:
(仅为主程序,更多代码在
解压密码: )
#include "Sets.h"
#include "themap.h"
#include "windows.h"
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
/*
功能:
演示Kruskal算法和Prim算法
集合的并,元素查找的操作及应用
说明:
代码均在vc++6.0环境下编译均通过
在非VC++6.0环境下编译请去掉头文件 windows.h 和函数 end()
如果NULL未定义请自定义
#define NULL 0 或
#define NULL ((void*)0)
作者:
hacker
时间:
2007.2.3
*/
const VSIZE = 7;//7个顶点
const INFINITY = 10000;//10000作为无穷大来处理
void LoadData(int cost[][VSIZE+1], Edge edge[]);
void end();
/*
函数名:
Kruskal 和 Prim
参数:
边,代价,边数,顶点数,最小代价生成树的顶点
返回值:
返回值为-1,不存在最小代价生成树
返回值大于0时为最小代价生成树的代价
最小代价生成树的边在vector<Edge>& t
*/
int Kruskal(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t);
int Prim (Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t);
int main()
{
int cost[VSIZE+1][VSIZE+1];//0不用
Edge edge[9];//9条边
vector<Edge> t;//用来存储最小代价生成树的顶点
int mincost;//最小代价
LoadData(cost, edge);
if ( (mincost = Kruskal(edge, cost, 9, VSIZE, t))!=-1)
{
cout<<"最小代价是:"<<mincost<<endl<<"边是:";
for (int i = 0;i<t.size();i++)
cout<<t[i];
cout<<endl;
}
t.clear();
if ( (mincost = Prim(edge, cost, 9, VSIZE, t))!=-1)
{
cout<<"最小代价是:"<<mincost<<endl<<"边是:";
for (int i = 0;i<t.size();i++)
cout<<t[i];
cout<<endl;
}
end();
return 1;
}
void LoadData(int cost[][VSIZE+1], Edge edge[])
{
edge[0].u = 1; edge[0].v = 2; edge[0].weight = 28;
edge[1].u = 1; edge[1].v = 6; edge[1].weight = 10;
edge[2].u = 2; edge[2].v = 3; edge[2].weight = 16;
edge[3].u = 2; edge[3].v = 7; edge[3].weight = 14;
edge[4].u = 3; edge[4].v = 4; edge[4].weight = 12;
edge[5].u = 4; edge[5].v = 5; edge[5].weight = 22;
edge[6].u = 4; edge[6].v = 7; edge[6].weight = 18;
edge[7].u = 5; edge[7].v = 6; edge[7].weight = 25;
edge[8].u = 5; edge[8].v = 7; edge[8].weight = 24;
for (int i=1;i<=7;i++)
for (int j=1;j<=i;j++)
cost[i][j] = cost[j][i] = INFINITY;
for (i=0;i<9;i++)
cost[edge[i].u][edge[i].v] =
cost[edge[i].v][edge[i].u] = edge[i].weight;
}
int Kruskal(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t)
{
Sets s(esize);
priority_queue<Edge, vector<Edge>, EdgeGreater> pq;
int mincost = 0;
for (int i = 0;i<esize;i++)
//把所有的边放入优先队列
pq.push(edge[i]);
i = 0;
while (i<vsize-1 && !pq.empty())
{
Edge temp = pq.top();//取出当前权最小的边
pq.pop();
int j = s.SimpleFind(temp.u);
int k = s.SimpleFind(temp.v);
if (j!=k)//如果不构成环
{
i++;
t.push_back(temp);
mincost +=cost[temp.u][temp.v];
s.SimpleUnion(j, k);
}
}
if (i!=vsize-1)
{
t.clear();
return -1;
}
else
{
return mincost;
}
}
int Prim(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t)
{
priority_queue<Edge, vector<Edge>, EdgeGreater> pq;
vector<Edge> sortededge;
int i;
for (i =0;i<esize;i++)
pq.push(edge[i]);
for (i =0;i<esize;i++)
{//对边进行从小到大排列,放到sortededge中
sortededge.push_back(pq.top());
pq.pop();
}
int distance[VSIZE+1];
int j;
int mincost = sortededge[0].weight;
Edge temp = sortededge[0];
t.push_back(temp);
for (i=1;i<=vsize;i++)
distance[i] = 1;//每个点都不在已生成树里
distance[temp.u] = distance[temp.v] = 0;//最短的边的两个点放到生成树里
for (i=2;i<=vsize-1;i++)
{//寻找另外的边
int exist = 0;//设置是否找到符合条件的边的状态标志为未找到
for (j=1;j<esize;j++)
if (distance[sortededge[j].u] ^ distance[sortededge[j].v] == 1)
{//由于边是排序好了的,所以从小边向大边找,找到的第一个符合条件的边可以
//加到生成树里
int k = (distance[sortededge[j].u] == 0) ? sortededge[j].v :\
sortededge[j].u;
distance[k] = 0;
mincost += sortededge[j].weight;
t.push_back(sortededge[j]);
exist = 1;
break;
}
if (!exist)
{
t.clear();
return -1;
}
}
return mincost;
}
void end()
{
if (MessageBox(NULL,\
"欢迎到学习交流(源代码在论坛下载)\n\t\t(确定后自动访问论坛)",\
"supcoder", IDOK) == IDOK)
{
char cmdLine[] = "iexplore ";
char path[256];
char buf[256];
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
PROCESS_INFORMATION ProcessInformation;
GetSystemDirectory(buf, 256);
sprintf(path, "%c:\\Program Files\\Internet Explorer\\IEXPLORE.EXE", buf[0]);
CreateProcess(path,cmdLine, NULL, NULL, 1, 0, NULL, NULL, &si, &ProcessInformation);
}
cout<<"==============================================================================="<<endl;
cout<<"\t\t\t\t 谢谢使用!"<<endl;
cout<<"\t\t\t "<<endl;
Sleep(1000);
}