图

最新推荐文章于 2023-11-27 12:55:57 发布
最新推荐文章于 2023-11-27 12:55:57 发布
阅读量445 收藏
点赞数
分类专栏： 数据结构知识点总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44811217/article/details/116083399
版权
本文深入探讨了图的基本概念，包括图的定义、关键术语，以及邻接矩阵和邻接表的存储结构。随后讲解了深度优先搜索（DFS）和广度优先搜索（BFS），以及图的连通性分析、Prim算法和Kruskal算法用于最小生成树的构建。此外，还涉及了最短路径问题，如单源最短路径算法（Dijkstra）和多源最短路径算法，以及DAG和拓扑排序的方法。
摘要由CSDN通过智能技术生成

文章目录

1 图的基本概念

  1. 图是一种复杂的非线性结构
  2. 任意两个节点之间都可能存在关系，即节点之间的连接关系是任意的

1.1 图的定义

	用G表示图，G=(V,E),其中V是G中顶点的有穷非空集合，E是V中顶点的偶对（称为边）的有穷集合，也称为图的边集。
	记G中顶点数为V(G)=|V|，边数E(G)=|E|，它们分别称为图G的阶和规模

1.2 图的相关术语

  1. 有向图和无向图：如果G中每条边都是都方向的，则G称为有向图，反之则为无向图
  2. 有向图用圆括号表示边，（V1,V2）表示V1与V2之间的边，无向图用尖括号表示边，<V1,V2>表示以V1为起点V2为终点的一条有向边。
  3. 完全图： 对于无向图，任意两顶点之间存在边；对于有向图，任意两顶点之间存在两条反向的边
  4. 度：无向图的度为所有与该顶点相连的边的数量极为该顶点的度，对于无向图，分为出度和入度，出度为所有以该顶点为起点的边数量，入度为所有以该顶点为终点的边的数量。

2. 图的存储结构

存储图的信息，主要包括两部分，顶点的信息和边的信息

2.1 邻接矩阵

用一个二维数组表示图中各顶点之间的关系
在这里插入图片描述

2.2 邻接矩阵的建立

typedef struct ENode ENode;
struct ENode
{
	int v1, v2;	//有向边
	int weight;	//权重
};
typedef struct Graph Graph;
struct Graph
{
	int Nv;		//顶点数
	int Ne;		//边数
	int G[MaxV][MaxV];
	int Data[MaxV];
};

2.3 邻接矩阵操作集

Graph* CreatGraph(int V)
{

	Graph* g = new Graph;
	g->Ne = 0;
	g->Nv = V;
	for (int i = 0; i < g->Nv;i++)
	{
		for (int j = 0; j < g->Nv; j++)
		{
			g->G[i][j] = MaxNum;
		}
	}
	return g;
}
void AddEdge(Graph* g, ENode& e)
{
	g->G[e.v1][e.v2] = e.weight;
}

2.4 邻接表

typedef struct ENode ENode;
struct ENode
{
	int v1, v2;	//有向边
	int weight;	//权重
};
typedef struct AdjNode AdjNode;
struct AdjNode
{
	int v;
	AdjNode* next;
};
typedef struct HeadNode HeadNode;
struct HeadNode
{
	//int data;
	AdjNode* next;
};
typedef struct Graph Graph;
struct Graph
{
	int Nv;		//顶点数
	int Ne;		//边数
	HeadNode* h;
	int Data[MaxV];
};

2.5 邻接表的操作集

Graph* CreatGraph(int V)
{

	Graph* g = new Graph;
	g->Ne = 0;
	g->Nv = V;
	g->h=new HeadNode[V]{};
	
	return g;
}
void AddEdge(Graph* g, ENode& e)
{
	g->h[e.v1].next=g->h[e.v2].next;
}

3. 图的遍历

3.1 深度优先搜索（DFS）

void DFS(Graph* g,int x)
{
	g->visit[x] = true;
	//do something
	for (int i = FindV(g, x); i >= 0; i = FindV(g, x))
	{
		if(!g->visit[i])
			DFS(g, i);
	}
	
}

3.2 广度优先搜索（BFS）

void BFS(Graph* g,int x)
{
	queue<int> q;
	q.push(x);
	//do something
	g->visit[x] = true;
	while(!q.empty())
	{
		int tmp = q.front();
		q.pop();
		for (int i = FindV(g, tmp); i >= 0; i = FindV(g, tmp))
		{
			if (!g->visit[i])
			{
				q.push(i);
				//do something
				g->visit[x] = true;
			}
		}
	}
}

4. 图的连通性

  1. 无向图：在遍历的时候对遍历过的结点计数，若节点数等于图的总结点数，则图是连通图

  2. 无向图：

     	强连通：若 G 是有向图，如果对图 G 中任意两个顶点 u 和 v，既存在从 u 到 v 的路径，
 也存在从 v 到 u 的路径，则称该有向图为强连通有向图。对于非强连通图，
 其极 大强连通子图称为其强连通分量。

 	单连通：若 G 是有向图，如果对图 G 中任意两个顶点 u 和 v，
 存在从 u 到 v 的路径或从 v 到 u 的路径，则称该有向图为单连通有向图。

 	弱连通：若 G 是有向图，如果忽略图 G 中每条有向边的方向，得到的无向图
 （即有向图的基图）连通，则称该有向图为弱连通有向图

5. 最小生成树

最小生成树：一棵树，所有顶点都在里面，共有| V |-1条边都在图里，同时边的权重和最小（贪心算法）

  1. 只能用图里有的边
  2. 不能有回路
  3. 正好用掉 V - 1条边

5.1 Prim算法 --O( |V|2 ) —>稠密图

/* 邻接矩阵存储 - Prim最小生成树算法 */

Vertex FindMinDist( MGraph Graph, WeightType dist[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    WeightType MinDist = INFINITY;

    for (V=0; V<Graph->Nv; V++) {
        if ( dist[V]!=0 && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回-1作为标记 */
}

int Prim( MGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType dist[MaxVertexNum], TotalWeight;
    Vertex parent[MaxVertexNum], V, W;
    int VCount;
    Edge E;
    
    /* 初始化。默认初始点下标是0 */
       for (V=0; V<Graph->Nv; V++) {
        /* 这里假设若V到W没有直接的边，则Graph->G[V][W]定义为INFINITY */
           dist[V] = Graph->G[0][V];
           parent[V] = 0; /* 暂且定义所有顶点的父结点都是初始点0 */ 
    }
    TotalWeight = 0; /* 初始化权重和     */
    VCount = 0;      /* 初始化收录的顶点数 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    E = (Edge)malloc( sizeof(struct ENode) ); /* 建立空的边结点 */
           
    /* 将初始点0收录进MST */
    dist[0] = 0;
    VCount ++;
    parent[0] = -1; /* 当前树根是0 */

    while (1) {
        V = FindMinDist( Graph, dist );
        /* V = 未被收录顶点中dist最小者 */
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;   /* 算法结束 */
            
        /* 将V及相应的边<parent[V], V>收录进MST */
        E->V1 = parent[V];
        E->V2 = V;
        E->Weight = dist[V];
        InsertEdge( MST, E );
        TotalWeight += dist[V];
        dist[V] = 0;
        VCount++;
        
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            if ( dist[W]!=0 && Graph->G[V][W]<INFINITY ) {
            /* 若W是V的邻接点并且未被收录 */
                if ( Graph->G[V][W] < dist[W] ) {
                /* 若收录V使得dist[W]变小 */
                    dist[W] = Graph->G[V][W]; /* 更新dist[W] */
                    parent[W] = V; /* 更新树 */
                }
            }
    } /* while结束*/
    if ( VCount < Graph->Nv ) /* MST中收的顶点不到|V|个 */
       TotalWeight = ERROR;
    return TotalWeight;   /* 算法执行完毕，返回最小权重和或错误标记 */
}

5.2 Kruskal算法 --O( |E| log |E| ) —>稀疏图

/* 邻接表存储 - Kruskal最小生成树算法 */

/*-------------------- 顶点并查集定义 --------------------*/
typedef Vertex ElementType; /* 默认元素可以用非负整数表示 */
typedef Vertex SetName;     /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */

void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
    ElementType X;

    for ( X=0; X<N; X++ ) S[X] = -1;
}

void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}

SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}

bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;

    Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
    Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */

    if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union( VSet, Root1, Root2 );
        return true;
    }
}
/*-------------------- 并查集定义结束 --------------------*/

/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
    int Parent, Child;
    struct ENode X;

    X = ESet[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
            Child++;  /* Child指向左右子结点的较小者 */
        if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}

void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;

    /* 将图的边存入数组ESet */
    ECount = 0;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;
            }
    /* 初始化为最小堆 */
    for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
        PercDown( ESet, ECount, Graph->Ne );
}

int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */

    /* 将最小边与当前堆的最后一个位置的边交换 */
    Swap( &ESet[0], &ESet[CurrentSize-1]);
    /* 将剩下的边继续调整成最小堆 */
    PercDown( ESet, 0, CurrentSize-1 );

    return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/


int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */

    InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
    ESet = (Edge)malloc( sizeof(struct ENode)*Graph->Ne );
    InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 初始化权重和     */
    ECount = 0;      /* 初始化收录的边数 */

    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while ( ECount < Graph->Nv-1 ) {  /* 当收集的边不足以构成树时 */
        NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        /* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
        if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
            /* 将该边插入MST */
            InsertEdge( MST, ESet+NextEdge );
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++; /* 生成树中边数加1 */
        }
    }
    if ( ECount < Graph->Nv-1 )
        TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */

    return TotalWeight;
}

6. 最短路径问题

求网络中两个结点间所有路径中，边的权值之和最小得到那一条路径
第一个顶点称为源点
最后一个顶点称为终点

6.1 无权图单源最短路径算法

void BFS_unweight(Graph* g,int x)
{
	queue<int> q;
	int* dist = new int[g->Nv];//记录各顶点到源点的距离，初始化全为-1
	int* path = new int[g->Nv];//记录各顶点到源点的路径，所存元素为路径中该顶点的上一个顶点，初始化全为-1
	Init(dist); Init(path);
	dist[x] = 0;
	while (!q.empty())
	{
		int tmp = q.front();
		q.pop();
		for (int i = FindV(g, tmp); i >= 0; i = FindV(g, tmp))
		{
			if (dist[i] != -1)
			{
				q.push(i);
				dist[i] = dist[tmp] + 1;
				path[i] = tmp;
			}
		}
	}
	q.push(x);
}
void Init(int p[])
{
	for (int i = 0; i < sizeof(p); i++)
	{
		p[i] = -1;
	}
}

6.2 有权图单源最短路径算法（Dijkstra算法）

两种寻找未收录顶点中 dist 最小的方式

  1. 直接扫描所有未收录顶点（稠密图） V2+E
  2. 将 dist 值存到最小堆中（稀疏图效果好） E log V
/* 邻接矩阵存储 - 有权图的单源最短路算法 */

Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    int MinDist = INFINITY;

    for (V=0; V<Graph->Nv; V++) {
        if ( collected[V]==false && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回错误标记 */
}

bool Dijkstra( MGraph Graph, int dist[], int path[], Vertex S )
{
    int collected[MaxVertexNum];
    Vertex V, W;

    /* 初始化：此处默认邻接矩阵中不存在的边用INFINITY表示 */
    for ( V=0; V<Graph->Nv; V++ ) {
        dist[V] = Graph->G[S][V];
        if ( dist[V]<INFINITY )
            path[V] = S;
        else
            path[V] = -1;
        collected[V] = false;
    }
    /* 先将起点收入集合 */
    dist[S] = 0;
    collected[S] = true;

    while (1) {
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;      /* 算法结束 */
        collected[V] = true;  /* 收录V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未被收录 */
            if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
                if ( Graph->G[V][W]<0 ) /* 若有负边 */
                    return false; /* 不能正确解决，返回错误标记 */
                /* 若收录V使得dist[W]变小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
                    dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路径 */
                }
            }
    } /* while结束*/
    return true; /* 算法执行完毕，返回正确标记 */
}

6.3 多源最短路径算法

两种算法：

  1. 直接将单源最短路径调用N次（稀疏图） V3 + E * V
  2. Floyd算法（稠密图） V3
/* 邻接矩阵存储 - 多源最短路算法 */

bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, k;

    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }

    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] ) {
                    D[i][j] = D[i][k] + D[k][j];
                    if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
                        return false; /* 不能正确解决，返回错误标记 */
                    path[i][j] = k;
                }
    return true; /* 算法执行完毕，返回正确标记 */
}

7. DAG（有向无环图）、拓扑排序

7.1 如何判断图有环

无向图： 深度优先遍历，是否会访问到已遍历的结点，若是，则有环；
有向图：生成树（判断回边)、拓扑排序（判断是否有剩余顶点没有访问）

7.2 拓扑排序 V+E

/* 邻接表存储 - 拓扑排序算法 */

bool TopSort( LGraph Graph, Vertex TopOrder[] )
{ /* 对Graph进行拓扑排序,  TopOrder[]顺序存储排序后的顶点下标 */
    int Indegree[MaxVertexNum], cnt;
    Vertex V;
    PtrToAdjVNode W;
       Queue Q = CreateQueue( Graph->Nv );
 
    /* 初始化Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        Indegree[V] = 0;
        
    /* 遍历图，得到Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        for (W=Graph->G[V].FirstEdge; W; W=W->Next)
            Indegree[W->AdjV]++; /* 对有向边<V, W->AdjV>累计终点的入度 */
            
    /* 将所有入度为0的顶点入列 */
    for (V=0; V<Graph->Nv; V++)
        if ( Indegree[V]==0 )
            AddQ(Q, V);
            
    /* 下面进入拓扑排序 */ 
    cnt = 0; 
    while( !IsEmpty(Q) ){
        V = DeleteQ(Q); /* 弹出一个入度为0的顶点 */
        TopOrder[cnt++] = V; /* 将之存为结果序列的下一个元素 */
        /* 对V的每个邻接点W->AdjV */
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( --Indegree[W->AdjV] == 0 )/* 若删除V使得W->AdjV入度为0 */
                AddQ(Q, W->AdjV); /* 则该顶点入列 */ 
    } /* while结束*/
    
    if ( cnt != Graph->Nv )
        return false; /* 说明图中有回路, 返回不成功标志 */ 
    else
        return true;
}
欲摘星辰
关注
专栏目录
【抛弃制作.9图片】Android基于png图片代码动态实现.9拉伸效果
在路上-codingAndlearning
09-22 1321
Android 实现.9拉伸效果的另径，不用画图也可以，动态生成chunk
〖Python自动化办公篇⑩〗- word文件自动化 - 设置图片样式与表格样式
易编橙 · 终身成长社群，相遇已是上上签！
05-14 4万+
上一章节学习了段落的样式之后，尤其是段落的居中。那么图片是否也可以以这样的方式居中呢？居中是可以的，但是实用的居中方法与段落居中的方式还是有一点区别的。
掌握AI图像篡改检测工具，轻松识别图片造假
热门推荐
努力让自己发光，对的人才能迎着光而来
07-13 11万+
掌握AI图像篡改检测工具，轻松识别图片造假
图片矫正
qq_40206924的博客
11-10 5414
基于顶点矫正的思路对于原始图片的边界有较高的要求（完整且清晰）。上面测试的两张图片在有边界（虽然边界不完美）的情况下不能矫正图片，并且还要考虑以下类型图片，可能要改变一下思路。
Unity的图片轮播
shijinlinaaa的博客
05-18 7064
unity的UI图片轮播，实现按顺序图片外部导入，获取图片名称，点击按钮滑动图片和鼠标滑动图片
使用opencv实现图片相似度检测
weixin_47039303的博客
11-27 2411
1.为什么学这个,我对图像处理非常感兴趣,我联想到海尔的指纹识别门锁是如何进行检测的,我在想不应该呀,单片机性能这么差,应该是使用了训练后的数据去检测图片的,如果我要实现草莓检测,知道它是不是草莓,我觉得单纯使用图片处理是不够的,我考虑过使用指纹模块来接触草莓从而实现判断他是不是草莓,从而联想到学习图像相似度检测,我们人类的手指事实上是有大量的传感器的,机器如果想要实现那科技含量太高了,而且成本高,就算实现了也只能放在家里自己玩…//啊这汽车和草莓是相似的?//straw1和straw3,不同图片的草莓。
Markdown：插入图片和图注
qq_32515081的博客
04-25 8117
在Markdown中插入图片，调节位置，大小，以及插入图注。 <center> <img style="border-radius: 0.3125em; box-shadow: 0 2px 4px 0 rgba(34,36,38,.12),0 2px 10px 0 rgba(34,36,38,.08);" width = "300" height = "200" src="在这里插入图片地址" width = "60%" alt=""/> .
HTML背景图片
weixin_52474888的博客
03-07 1万+
在我们日常的生活中，经常会见到一些网页背景是一张图片，那么怎么设置出这种效果呢,小编就带着大家一起来学习一下。 首先大家需要料及一个属性：background-image ，通过这个属性来设置背景图片。用url来引入图片位置 background-image: url(F2581BA79A437DCC9807D1311783E298.jpg); 然后我们引入图片之后，来了解一下如何设置你引入的图片 1，background--repeat 这个属性是用来设置图片的显示方式 repeat,图片重复
echarts散点图加图片
ml1658503的博客
09-05 1518
在echarts散点图上加图片
文字生成图片：输入描述语，人工智能自动帮你绘图！
地理信息系统、摄影测量与遥感、人工智能
08-17 1万+
根据你的输入，人工智能自动生成图片
ThinkphpUploadPic单图片上传+多图片上传
03-27
thinkphp+单图片上传+多图片上传（ThinkphpUploadPic） ##单图片上传：使用修改后的uploadify插件 使用方法： 1、添加/Public/plugins/uploadify文件夹； 2、html：见onePic.html,主要是引入js和css文件，在js...
点击图片弹出大图效果交互
08-03
在网页设计中，点击图片弹出大图效果是一种常见的交互设计，它为用户提供了一种查看高清晰度图像的便捷方式。这种效果通常通过JavaScript（JS）实现，因为JS具有动态控制网页元素的能力，可以轻松地处理用户的点击...
微信小程序上传图片包含多图上传，支持9图，无限制图片数目
02-23
本篇文章将深入探讨微信小程序如何实现多图上传，包括单图上传、9图上传以及无限制图片数目的上传策略。 首先，我们要了解微信小程序中的`wx.chooseImage`接口，这是用于选择本地相册或拍照获取图片的关键函数。它...
最全的android图片加密
11-26
在加密图片时，我们可以在原始数据中随机插入一些无关的字节，使得即使获取了加密后的数据，没有正确的“混入”规则也无法还原原图。这种方法可以进一步提高数据的安全性，防止针对AES等标准加密方式的攻击。 在...
基于VUE选择上传图片并页面显示（图片可删除）
08-30
基于VUE选择上传图片并页面显示（图片可删除） 本资源主要介绍了基于VUE选择上传图片并页面显示的效果，图片可以删除。该效果通过VUE框架实现图片上传和显示，并提供了删除图片的功能。下面我们将对该资源的知识点...
基于C语言的Dao编程语言设计源码
最新发布
09-28
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。
如何自定义数据集进行目标检测_keras-yolo3.zip
09-28
如何自定义数据集进行目标检测_keras-yolo3
基于JavaScript及多语言融合的勤工俭学平台设计源码
09-28
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。
初始化对LoRA微调动态的影响研究
09-28
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。 适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。 使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。 其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。
JavaScript 图片类型检测函数
在给定的代码示例中，我们看到一个JavaScript函数`isImg()`，它的主要目的是判断用户通过`<input type="file">`选择的文件是否是图片类型。这个函数对于防止非法文件上传、维护网站安全和提供良好的用户体验至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值