图生成算法
Ⅰ 图的所有生成树的算法
边构成,并包含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);
}
Ⅱ 求图的生成树的算法有哪些
在图论中，对于这种权值固定且为正的连通图来说，有比较成熟的最小生成树算法。如着名的Prim算法和Kruskal算法，这两个算法都是贪心算法的例子Prim算法的时间复杂度为 ，适合求边稠密的网络图的最小生成树；Kruskal算法的时间复杂度为 ，适合求边稀疏的网络图的最小生成树。
Ⅲ 图的最小生成树算法
图的生成树和最小生成树生成树(SpanningTree):如果一个图的子图是一个包含图所有节点的树,那这个子图就称为生成树.
Ⅳ 最小生成树的两种算法 图的最小生成树的两个主要算法是什么它们各自的特点
主要有两个：
1.普里姆（Prim)算法
特点：时间复杂度为O(n2).适合于求边稠密的最小生成树.
2.克鲁斯卡尔（Kruskal)算法
特点：时间复杂度为O(eloge)(e为网中边数）,适合于求稀疏的网的最小生成树.
Ⅳ 怎么通过算法大量生成图片
首先需要制作一个nodejs小程序，然后通过该程序开始运行算法，通过小程序的建模生成图片，这样就可以通过算法生成大量的图片。
首先，先介绍广告创意图片的整体生成流程：用户先提供必要的信息，如广告标题、促销信息、广告商品图等，然后通过接口发送做图程序。
做图程序是一个nodejs服务，nodejs会启动一个后端的headless模式的chrome，我们使用的是puppeteer，然后puppeteer启动真正的做图程序。
做图主程序使用js和canvas进行编写，js根据传入的参数，计算出最合适的模板，然后进行配色、配置背景图、装饰文本、装饰商品图等各种繁琐细节的操作，最终在HTML里通过canvas渲染出所有的创意图片。
最后再通过nodejs，做图完成，nodejs再调用puppeteer计算位置关系等进行截图，生成最终的图片。
Ⅵ petri网可达图生成算法的编程。。。
M=256;%原图像长度 N=32;%水印图像长度 K=8; %图像分块大小 I=zeros(M,M);%创建一个零矩阵，用于存放载体图像 J=zeros(N,N); %创建一个零矩阵，用于存放水印图像 BLOCK=zeros(K,K);%创建一个零矩阵，用于存放图像分块 %显示水印图像 subplot(1,8,2); J=imread('14','bmp'); %读入水印图像 imshow(J); %显示水印图像 title('水印图像'); %显示原图像 subplot(1,3,2); I=imread('11','bmp'); %读入原始图像 imshow(I); %显示原始图像 title('原始公开图像'); %嵌入水印 tem=1;%创建变量tem，没用 for p=1:N%水印图像行循环 for q=1:N%水印图像列循环 x=(p-1)*K+1; %x为载体图像行坐标 y=(q-1)*K+1; %y为载体图像列坐标 BLOCK=I(x:x+K-1,y:y+K-1); %BLOCK为载体图像I的分块，分块大小为K*K，...
Ⅶ 以圆的Bresenham生成算法为例,图解矢量图形和光栅图形的区别
有电子艺术图像被分为两种核心类型：光栅图像（也称为“位图”）和矢量图像。简而言之，光栅图像由连接的点组成，矢量是由连接的线组成的图像。这两种格式彼此完全不同，但当适当地用于所需的最终输出方法时，它们彼此形成对比和互补。光栅图像通过扫描源图稿或使用照片编辑或绘图程序（如Corel、PhotoPAINT或Adobe PhotoShop）“绘画”来创建，而矢量图像是通过使用CorelDRAW或Adobe Illustrator等矢量插图程序绘制的过程来创建的。
一、Bresenham算法原理
由Bresenham提出的一种精确而有效的光栅线生成算法，可用于显示线、圆和其他曲线的整数增量运算。它是目前最有效的线段生成算法。
推导：
设线段端点：(,),(,),∆x和∆y为水平和垂直偏移量,m为斜率
当|m| <= 1时,对于给定的x增量∆x
当|m| >= 1时,对于给定的y增量∆y，
（当 0<m < 1）
假设已经确定了要显示的像素，那么，需要确定下一点是绘制在，
还是。
根据直线的方程，直线上处的y坐标为：
将m带入d1 – d2中，并变换得：
其中，为算法中第k步的决策参数，c为一常量，其值为。
那么：
若，即,有
若, 即,有
同理，可求得第k+1步的决策参数
因此，有如下递推关系：
因为0<m<1 因此，带入上式得：
其中，的值取决于的值：
当时，，
当时， ，
Bresenham算法描述 (0 < m < 1)
算法从线段的起始端点开始，反复计算每个点的决策参数并绘制像素。
起始端点处的决策参数为：
算法：
1、输入线段的两个端点，并将左端点存储在中；
2、将装入帧缓冲器，画出第一个点；
3、计算常量∆x，∆y，2∆y 和2∆y – 2∆x，并得到决策参数的第一个值：
4、从k = 0开始，在沿线的每个处，进行下列检测：
若，下一个待画点是，且
若 ，下一个待画点是，且
5、重复步骤4，共∆x次。
————————————————
版权声明：本文为CSDN博主“地泽万物”的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41883085/article/details/102706471
Ⅷ （专家进来）双代号网络图自动生成算法
还没有研究出来，如果你愿意等，十年八年应该没问题能搞定，嘻嘻
、、、
老大加油，，，
Ⅸ voronoi图的生成方法
四叉树归并构成VORONOI图的算法
}
int gridnum;
int seq;
int totalnum;
int gridnum;
}
class voronoi{
struct graph{
CDC Polygon();
}
struct onlineincremeth{
}
}
class grid{
void
int num.range；
int serial；
int totalnum；
int pointnum；
int pointtotalnum；
int layer；
int morton.availabledigit；
int morton.lastdigit;
Ⅹ 求图论的生成子图算法，要求生成尽可能多的子图
在图论的历史中，还有一个最着名的问题－－四色猜想。这个猜想说，在一个平面或球面上的任何地图能够只用四种颜色来着色，使得没有两个相邻的国家有相同的颜色。每个国家必须由一个单连通域构成，而两个国家相邻是指它们有一段公共的边界，而不仅仅只有一个公共点。20世纪80-90年代曾邦哲的综合系统论（结构论）观将“四色猜想”命题转换等价为“互邻面最大的多面体是四面体”。四色猜想有一段有趣的历史。每个地图可以导出一个图，其中国家都是点，当相应的两个国家相邻时这两个点用一条线来连接。所以四色猜想是图论中的一个问题。它对图的着色理论、平面图理论、代数拓扑图论等分支的发展起到推动作用。 （下图是在上下对折再左右对折以后形成一个轮胎形状，有7个区域两两相连，就是说在一个环面上作图，需要7种颜色，外国数学家构造林格证明：Np=[(7+√1+48p)/2]，p=1，N1=7。
图论中最着名的四色猜想解决办法 韩世君利用三角形性质和数学归纳法解决了四色猜想 摘要：将平面图的不相连点使其相连（这样增加着色难度），形成有许多三角形相连的平面图，根据三角形的稳定性，利用数学归纳法，平面图进行着色最多需4种颜色。 定理：在平面图中,对不同顶点进行着色,相邻顶点着不同颜色,不相邻顶点着相同颜色,则最多需4种颜色。 证明：在平面图中，不在同一直线上的三点决定一个平面，那么三点构成的三角形是平面图中最基本、最简单、最稳定、密闭的图形。 由于在对地图着色过程中不考虑图的具体形状只考虑点是否相邻，将平面图的不相连点使其相连（这样增加着色难度），形成有许多三角形相连的平面图（三点以下肯定成立）。如图1：添加辅助线（不相邻的点使其相邻，这样就增加了着色的色数，有利于证明），将图1分解为4个△ABC。 在平面图中的无数点中，任取相邻三点构成各点相邻的△ABC（见图2），则需3种颜色A B C,在平面图中再任取一点 D 与 A B C 三点相邻,同时D又与A B C三点相连后形成三角形。任取一点E与 A、B、C、D四色相连，E必与四色之一色相同即E点在△ABD中与C色相同、在△ACD中与B色相同、在△BCD中与A色相同、在△ABC外与D色相同，E与另外三色相连形成新的三角形。 在三角形的三点之外任取一点只有在三角形的内部和外部两种情况且这两种情况的点不会相邻，该点最多与三角形的三点相连且又形成新的三角形。 继续选取一点进行着色，该点同样最多与三角形的三点相连且又形成新的三角形，该点至少为四色中的一色。逐点（第n点）着色至将所有点（第n+1点）着色只须A、B、C、D四色其中一色。 图的着色方法：任意一张地图，将孤立的点用一种颜色着色（A色），不能形成密闭图形的相连的点用两种颜色（A、B色）。将剩余的点不相连的用虚线使其相连形成许多三角形，完全不相连的图不进行相连。任取相连三点着三种颜色（A、B、C色），再取与其相连的点，如果与A、B、C三色的点都相连着D色，否则着与其不相连的其中一色，用虚线相连的点可以用同一种颜色也可以用两种颜色，依次取与着色的点相连的点用以上方法进行着色。这样对所有的点进行着色最多用四色（A、B、C、D色）。 图论的广泛应用，促进了它自身的发展。20世纪40-60年代，拟阵理论、超图理论 、极图理论，以及代数图论、拓扑图论等都有很大的发展 拓扑学在泛函分析、李群论、微分几何、微分方程和其他许多数学分支中都有广泛的应用。 （右图是：下面的三叉安在上面的环面上，就是有3个洞的9个两两相连区域，上面的图上下对折再左右对折就是一个轮胎形状环面图2）
左图是亏格为4时10个两两相连区域构造，上图上下对折，再左右对折，形成一个轮胎形状，再把下面的四叉按照A,B,C,D编号安上，就是有4个洞的两两相连区域图3（王晓明构造）。