创建图算法

⑴ 教你用AI创造无价，让你少走弯路

Ai生成图像前后一看，这简直比PS厉害十倍吧！
Ai生成图像的逻辑到底是什么呢？
就是透过机器 “学习算法” 来学习特定图像的统计规律，并在此基础上生成新的图像。

算法主要有两种
GAN（生成对抗网路）
VAE（变分自编码器）
这些算法的核心思想是透过对大量图像的学习，学习它们的隐含分布，进而生成新的图像。
GAN透过生成器和判别器的对抗学习，来生成与真实图像相似的图像；
VAE透过学习对潜在变量的编码和解码，来生成具有多样性的图像。

总体而言，生成图像的逻辑是透过学习和推断来生成具有特定特征和多样性的图像

基本逻辑：
上传照片 → 生成idname → 替换
·需要先邀请InsightFaceSwap bot到自己的服务器(聊天室)，邀请通过谷歌搜索，自动连接至Discord
·邀请成功后会在窗口右侧看见它(机器人)
·对话框输入“/”调出InsightFaceSwap bot插件，点击“/savied“弹出图片上传窗口
·添加想要替换的图片，图中以Lisa为例，起一个id名字
·找到或上传已生成的Ai绘画图片，点击"APP"选项，点击“INSwaper”
·融合成功！

尽量选取高清且噪点少的图片进行上传
如果idname创建失败，先检查是否名字被占用，如果被占用，重新输入一个新名字。
idname创建失败有可能是网络原因，如果没有上面问题，请多尝试几次

⑵ 快速绘制流程图方法

流程图，以特定的图形符号加上说明，表示算法的图，称为流程图或框图，使用图形表示算法的思路是一种极好的方法，因为千言万语不如一张图。

1、首先打开电脑上安装好的迅捷流程图软件。

2、流程图软件打开之后，在软件界面中点击“文件”菜单下的“新建”按钮。

3、点击“新建”按钮之后，就会出现一个小窗口，在这窗口中看到很多流程图的模板，选择一个模板 点击一下就能使用了。

4、当流程图模板创建好之后，选中一个图形双击两下就能输入文字，文字输入好之后，选中文字，在软件右侧有一个“文本”工具，使用这个文本工具就能设置文字的样式了。

5、文字输入好之后，接下来就是修改图形的颜色，使用流程图软件右上角的“样式”工具，就能修改图形的颜色了。

6、最后，流程图绘制好之后，点击“文件”菜单下的“另存为”或者“保存”按钮就能将绘制好的流程图保存在电脑上了。

⑶ C++编写程序 关于【图的遍历】

里面多了查找路径功能。
#define t true
#define f false
#include<iostream.h>
struct node//定义一个结构作为节点类型
{
int data;
bool sign;//标志位,用来标示是否遍历过
node *next;
};
node* creategraph()//建立邻接表，完成无向图的输入
{
int l,m,n;
bool g;
cout<<"请输入节点数: ";
cin>>n;
node *adjacencylist=new node[n+1];//动态分配节点数组内存
adjacencylist[0].data=n;//0地址存放的为节点数
adjacencylist[0].next=NULL;
for(int i=1;i<=n;i++)//给各顶点域赋初值
{
adjacencylist[i].data=0;
adjacencylist[i].next=NULL;
adjacencylist[i].sign=f;//表示未遍历
}
cout<<"请依次输入各条边的始点和尾点:（以0表示结束）"<<endl;
cin>>l;
if(l!=0)//判断输入边是否结束
g=t;
while(g==t)
{
cin>>m;
if((l>0)&&(l<=n)&&(m>0)&&(m<=n))//判断输入顶点是否正确
{
node *p,*q,*top;
p=(node *)new(node);//分配边的一个顶点内存
p->data=m;
p->next=NULL;
if(adjacencylist[l].next==NULL)//为每个节点创建邻接链表
adjacencylist[l].next=p;
else
{
top=adjacencylist[l].next;
while(top->next!=NULL)
top=top->next;
top->next=p;
}
adjacencylist[l].data++;//统计邻接点的个数
q=(node *)new(node);//分配边的另一个顶点内存
q->data=l;
q->next=NULL;
if(adjacencylist[m].next==NULL)//构建邻接表
adjacencylist[m].next=q;
else
{
top=adjacencylist[m].next;
while(top->next!=NULL)
top=top->next;
top->next=q;
}
adjacencylist[m].data++;//统计邻接点的个数
}
else
cout<<"边"<<l<<"--"<<m<<"输入错误！"<<endl;//错误输入标识
cin>>l;
if(l==0)//边的输入结束
g=f;
}
return adjacencylist;//返回邻接表
};
void DepthFirstSearch(node *list)//深度优先搜索
{
int m,n=list[0].data,k,*a=new int[n];//设置一个数组用于存放节点
node *p;
cout<<"采用深度优先搜索："<<endl;
cout<<"请输入搜索起始节点：";
cin>>k;
for(int i=0;i<n;i++)
{
a[i]=k;
list[k].sign=t;
if(i==n-1)
break;
m=0;
while(list[k].sign==t)
{
p=list[k].next;
while(p!=NULL)//找出list[k]链表中的未遍历节点
{
k=p->data;
p=p->next;
if(list[k].sign==f)
break;
}
m++;
if(list[k].sign!=f)//判断是否是p=NULL跳出while循环的
{
if(i<m)//无节点可回溯
{
cout<<"该图为非连通图!"<<endl;
break;
}
else
k=a[i-m]; //回溯
}
}
}
for(i=1;i<=n;i++)//恢复原邻接表
list[i].sign=f;
cout<<"深度优先搜索遍历顺序为:";
for(i=0;i<n;i++)//输出遍历结果
cout<<a[i]<<" ";
cout<<endl;
delete a;//释放动态数组内存
};
void BreadthFirstSearth(node *list)//广度优先搜索
{
int m,r,k,n=list[0].data,*a=new int[n+1];//设置数组存放节点
node *p;
cout<<"采用广度优先搜索："<<endl;
cout<<"请输入搜索起始节点：";
cin>>k;
a[0]=n;
a[1]=k;
list[k].sign=t;//标识遍历的第一个节点
m=0;
r=1;
while(m!=r)
{
m++;
p=list[a[m]].next;
while(p!=NULL)
{
k=p->data;
if(list[k].sign==f)
{
r++;
a[r]=k;//遍历到的节点存入数组
list[k].sign=t;//标识已经遍历过的节点
}
p=p->next;
}
}
for(int i=1;i<=n;i++)//恢复原邻接表
list[i].sign=f;
cout<<"广度优先搜索遍历顺序为: ";
for(i=1;i<=n;i++)//输出遍历
cout<<a[i]<<" ";
cout<<endl;
delete a;//释放动态数组内存
};
void PathSearth(node *list)//路径搜索
{
int *a,c,d,m,k,n=list[0].data;
cout<<"请输入起始点：";
cin>>k;
cout<<"请输入尾节点：";
cin>>c;
cout<<"请输入要找的路径长度：";
cin>>d;
d=d+1;
if(d>n)
cout<<"不存在这样的简单路径！"<<endl;
else
{
a=new int[d];//动态分配数组内存存放路径上的节点
for(int i=0;i<d;i++)
a[i]=0;
a[0]=k;
node *p;
int x;
list[a[0]].sign=t;
i=1;
while(a[d-1]!=c)
{
while(i<d)
{
x=1;
p=list[a[i-1]].next;
while(p!=NULL)
{
m=p->data;
if(i==d-1&&m==a[0]&&a[0]==c)//路径存在且为回路
{
cout<<"该路径为一条回路！"<<endl;
a[i]=m;
i++;
break;
}
if(list[m].sign==f)
{
if(a[i]!=0)
{
if(x==0)//是否为已经判断过的错误路径
{
a[i]=m;
list[a[i]].sign=t;//标识走过节点
i++;
break;
}
if(a[i]==m)//设置错误路径标识
x=0;
}
else
{
a[i]=m;
list[a[i]].sign=t;//标识走过节点
i++;
break;
}
}
p=p->next;
}
if(p==NULL)
{
a[i]=0;
i--;//由此节点往下的路径不存在,回溯
list[a[i]].sign=f; //还原标识符
}
if(i==0)//无法回溯,路径不存在,跳出循环
{
cout<<"不存在这样的简单路径！"<<endl;
break;
}
}
if(i==0)//无法回溯,路径不存在,跳出循环
break;
if(a[d-1]!=c)//路径不是所要找的
{
i--; //回溯
if(i>=0)
list[a[i]].sign=f;//还原标识符
}
}
if(a[d-1]==c)//判断路径是否找到并输出
{
cout<<"从节点"<<k<<"到节点"<<c<<"的一条路径为：";
for(i=0;i<d-1;i++)//输出路径
cout<<a[i]<<"--> ";
cout<<a[d-1]<<endl;
}
delete a;
}
for(int i=1;i<=n;i++)//恢复原邻接表
list[i].sign=f;
};
void AdjacencyListDelete(node *list)//释放邻接表的空间
{
node *p,*q;
int n=list[0].data;
for(int i=1;i<=n;i++)
{
p=list[i].next;
while(p!=NULL)
{
q=p->next;
delete p;//释放链表节点空间
p=q;
}
}
delete list;//释放邻接表空间
};
void main()
{
node *list;
list=creategraph();//以邻接表的形式建立一个无向图
char a,b;
cout<<"请选择遍历方法：（d:深度优先搜索;b:广度优先搜索）";
for(int i=1;i<2;i++)
{
cin>>a;
switch(a)
{
case 'd':
case 'D': DepthFirstSearch(list);
cout<<"是否采用广度优先搜索重新遍历？（y:是;n:否）";
cin>>b;
if((b=='y')||(b=='Y'))
BreadthFirstSearth(list);
break;
case 'b':
case 'B': BreadthFirstSearth(list);
cout<<"是否采用深度优先搜索重新遍历？（y:是;n:否）";
cin>>b;
if((b=='y')||(b=='Y'))
DepthFirstSearch(list);
break;
default: cout<<"输入错误！请重新输入！"<<endl;
i--;
}
}
while(1)
{
cout<<"是否搜索路径？（y:是;n:否）";
cin>>a;
if((a=='y')||(a=='Y'))
PathSearth(list);
else if((a=='n')||(a=='N'))
break;
else
cout<<"输入错误！"<<endl;
}
AdjacencyListDelete(list);//释放邻接表空间
}