图

最新推荐文章于 2022-05-10 14:20:52 发布
最新推荐文章于 2022-05-10 14:20:52 发布
阅读量571 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： struct 存储 path 测试 c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jtlyuan/article/details/7381326
版权

图：图（Graph）是由定点的有穷非空集合和定点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中的顶点的集合，E是图G中边的集合。

图的两个重要的存储方式：

1、 邻接矩阵：

/**************图数据结构***********************/

#define VERTEX_MAX 26   //图的最大顶点数  

#define MAXVALUE 32767 //最大值(可设为一个最大整数)

typedef struct

{

    char Vertex[VERTEX_MAX]; //保存顶点信息(序号或字母)                                                                                                 

    int Edges[VERTEX_MAX][VERTEX_MAX]; //保存边的权

    int isTrav[VERTEX_MAX]; //遍历标志

    int VertexNum; //顶点数量

    int EdgeNum;//边数量

    int GraphType; //图的类型(0:无向图，1:有向图)   

}MatrixGraph; //定义邻接矩阵图结构

 

void CreateMatrixGraph(MatrixGraph *G);//创建邻接矩阵图

void OutMatrix(MatrixGraph *G); //输出邻接矩阵

 

/***********创建邻接矩阵存储方式的图****************/

void CreateMatrixGraph(MatrixGraph *G)//创建邻接矩阵图

{

    int i,j,k,weight;

    char start,end; //边的起始顶点

    printf("输入各顶点信息\n");

    for(i=0;i<G->VertexNum;i++) //输入顶点

    {

        getchar();

        printf("第%d个顶点:",i+1);

        scanf("%c",&(G->Vertex[i])); //保存到各顶点数组元素中

    }

    printf("输入构成各边的两个顶点及权值(用逗号分隔):\n");

    for(k=0;k<G->EdgeNum;k++)  //输入边的信息

    {

        getchar(); //暂停输入

        printf("第%d条边：",k+1);

        scanf("%c,%c,%d",&start,&end,&weight);

        for(i=0;start!=G->Vertex[i];i++); //在已有顶点中查找始点

        for(j=0;end!=G->Vertex[j];j++); //在已有顶点中查找结终点

        G->Edges[i][j]=weight; //对应位置保存权值，表示有一条边

        if(G->GraphType==0)  //若是无向图

            G->Edges[j][i]=weight;//在对角位置保存权值 

    }

}

/***********输出邻接矩阵存储方式的图****************/

void OutMatrix(MatrixGraph *G)//输出邻接矩阵

{

    int i,j;

    for(j=0;j<G->VertexNum;j++)

        printf("\t%c",G->Vertex[j]);          //在第1行输出顶点信息

    printf("\n");

    for(i=0;i<G->VertexNum;i++)

    {

        printf("%c",G->Vertex[i]);

        for(j=0;j<G->VertexNum;j++)

        {

            if(G->Edges[i][j]==MAXVALUE) //若权值为最大值

                printf("\t∞");          //输出无穷大符号

            else

                printf("\t%d",G->Edges[i][j]); //输出边的权值

        }

        printf("\n");

    }            

}

 

/*******************测试代码*******************************/

int main()

{

    MatrixGraph G; //定义保存邻接矩阵结构的图

    int i,j;

    printf("输入生成图的类型(0:无向图,1:有向图):");

    scanf("%d",&G.GraphType); //图的种类

    printf("输入图的顶点数量和边数量:");

    scanf("%d,%d",&G.VertexNum,&G.EdgeNum); //输入图顶点数和边数

    for(i=0;i<G.VertexNum;i++)  //清空矩阵

        for(j=0;j<G.VertexNum;j++)

            G.Edges[i][j]=MAXVALUE; //设置矩阵中各元素的值为最大值        

    CreateMatrixGraph(&G); //创建用邻接表保存的图

    printf("邻接矩阵数据如下:\n");

    OutMatrix(&G);

    getch();

    return 0;

}

 

2、 邻接表存储方式：

/************************图邻接表存储结构****************/

#define VERTEX_MAX 20   //图的最大顶点数  

typedef struct edgeNode  

{

    int Vertex; //顶点信息(序号或字母)

    int weight; //权值

    struct edgeNode *next; //指向下一个顶点指针 (当前顶点和指向的下一顶点构成一条边)

}EdgeNode; //邻接表边结构

 

typedef struct  

{

    EdgeNode* AdjList[VERTEX_MAX]; //指向每个顶点的指针

    int VextexNum,EdgeNum; //图的顶点的数量和边的数量                                                                                                                 

    int GraphType; //图的类型(0:无向图，1:有向图)

}ListGraph;  //图的结构

 

void CreateGraph(ListGraph *G); //生成图的邻接表  

void OutList(ListGraph *G); //输出邻接表

 

/************************创建图邻接表存储结构****************/

void CreateGraph(ListGraph *G)  //构造邻接表结构图

{

    int i,weight;

    int start,end;

    EdgeNode *s;

    for(i=1;i<=G->VextexNum;i++)//将图中各顶点指针清空

        G->AdjList[i]=NULL;

    for(i=1;i<=G->EdgeNum;i++) //输入各边的两个顶点

    {

        getchar();

        printf("第%d条边:",i);

        scanf("%d,%d,%d",&start,&end,&weight); //输入边的起点和终点

        s=(EdgeNode *)malloc(sizeof(EdgeNode)); //申请保存一个顶点的内存

        s->next=G->AdjList[start]; //插入到邻接表中

        s->Vertex=end; //保存终点编号

        s->weight=weight; //保存权值

        G->AdjList[start]=s; //邻接表对应顶点指向该点

        if(G->GraphType==0) //若是无向图，再插入到终点的边链中

        {

            s=(EdgeNode *)malloc(sizeof(EdgeNode)); //申请保存一个顶点的内存

            s->next=G->AdjList[end];

            s->Vertex=start;

            s->weight=weight;

            G->AdjList[end]=s;

        }

    }  

}

/************************输出图邻接表存储结构****************/

void OutList(ListGraph *G)

{

    int i;

    EdgeNode *s;

    for(i=1;i<=G->VextexNum;i++)

    {

        printf("顶点%d",i);

        s=G->AdjList[i];

        while(s)

        {

            printf("->%d(%d)",s->Vertex,s->weight);

            s=s->next;

        }

        printf("\n");

    }

}

 

/*****************测试代码**************************/

int main()

{

    ListGraph G; //定义保存邻接表结构的图

    printf("输入生成图的类型(0:无向图,1:有向图):");

    scanf("%d",&G.GraphType); //图的种类

    printf("输入图的顶点数量和边数量:");

    scanf("%d,%d",&G.VextexNum,&G.EdgeNum); //输入图顶点数和边数

    printf("输入构成各边的两个顶点及权值(用逗号分隔):\n");

    CreateGraph(&G); //生成邻接表结构的图

    printf("输出图的邻接表:\n");

    OutList(&G);

    getch();

    return 0;

}

 

深度优先遍历

 深度优先遍历方法类似于树的先序遍历，具体过程如下：

（1）从isTrav数组中选择一个未被访的顶点Vi，将其标记为已访问。

（2）接着从Vi的一个未被访问过的邻接点出发进行深度优先遍历。

（3）重复步骤（2），直至图中所有和Vi有路径相通的顶点都被访问过。

（4）重复步骤（1）至步骤（3）的操作，直至所有顶点都被访问过。

广度优先遍历

                  广度优先遍历类似于树的按层次遍历，具体过程如下：

（1）从isTrav数组中选择一个未被访问的顶点Vi，将其标记为已访问。

（2）接着依次访问Vi的所有未被访问的邻接点，并标记为已被访问过。

（3）从这些邻接点出发进行广度优先遍历，直至图中所有和Vi有路径相通的顶点都被访问过。

（4）重复步骤（1）至步骤（3）的操作，直至所有顶点都被访问过。

 

/*****************本程序是以邻接矩阵存储方式的图的*********************/

#include <stdio.h>

#include "3-6 AdjMatrixGraph.c"

#define QUEUE_MAXSIZE 30 //队列的最大容量

typedef struct

{

    int Data[QUEUE_MAXSIZE]; //数据域

    int head; //队头指针

    int tail; //队尾指针

}SeqQueue; //队列结构

//队列操作函数

void QueueInit(SeqQueue *q); //初始化一个队列  

int QueueIsEmpty(SeqQueue q); //判断队列是否空  

int QueueIn(SeqQueue *q,int n); //将一个元素入队列  

int QueueOut(SeqQueue *q,int *ch); //将一个元素出队列                                                                                                         

 

//图操作函数

void DFSTraverse(MatrixGraph *G); //深度优先遍历

void BFSTraverse(MatrixGraph *G); //广度优先遍历

void DFSM(MatrixGraph *G,int i);

void BFSM(MatrixGraph *G,int i);

 

void QueueInit(SeqQueue *Q)    //队列初始化 

{

    Q->head=Q->tail=0;

}

int QueueIsEmpty(SeqQueue Q)   //判断队列是否已空，若空返回1,否则返回0

{

    return Q.head==Q.tail;

}

int QueueIn(SeqQueue *Q,int ch)   //入队列，成功返回1，失败返回0  

{

    if((Q->tail+1) % QUEUE_MAXSIZE ==Q->head) //若队列已满

        return 0;  //返回错误;

    Q->Data[Q->tail]=ch; //将数据ch入队列

    Q->tail=(Q->tail+1) % QUEUE_MAXSIZE; //调整队尾指针

    return 1; //成功，返回1

}

int QueueOut(SeqQueue *Q,int *ch)   //出队列,成功返回1，并用ch返回该元素值，失败返回0 

{

    if(Q->head==Q->tail) //若队列为空

        return 0; //返回错误

    *ch=Q->Data[Q->head]; //返回队首元素

    Q->head=(Q->head+1) % QUEUE_MAXSIZE; //调整队首指针

    return 1; //成功出队列，返回1  

}  

 

/*********************深度优先遍历**************************/

void DFSTraverse(MatrixGraph *G) //深度优先遍历

{

    int i;

    for(i=0;i<G->VertexNum;i++) //清除各顶点遍历标志

        G->isTrav[i]=0;

    printf("深度优先遍历结点:");

    for(i=0;i<G->VertexNum;i++)

        if(!G->isTrav[i]) //若该点未遍历

            DFSM(G,i); //调用函数遍历

    printf("\n");

 

}

void DFSM(MatrixGraph *G,int i) //从第i个结点开始，深度遍历图

{

    int j;

    G->isTrav[i]=1; //标记该顶点已处理过

    printf("->%c",G->Vertex[i]);//输出结点数据

//    printf("%d->",i); //输出结点序号

 

    //添加处理节点的操作

    for(j=0;j<G->VertexNum;j++)

        if(G->Edges[i][j]!=MAXVALUE && !G->isTrav[i])

            DFSM(G,j); //递归进行遍历

}

 

/*********************广度优先遍历**************************/

void BFSTraverse(MatrixGraph *G) //广度优先

{

    int i;

    for (i=0;i<G->VertexNum;i++) //清除各顶点遍历标志

        G->isTrav[i]=0;

    printf("广度优先遍历结点:");

    for (i=0;i<G->VertexNum;i++)

        if (!G->isTrav[i])

            BFSM(G,i);

    printf("\n");

}

void BFSM(MatrixGraph *G,int k) //广度优先遍历

{

    int i,j;

    SeqQueue Q; //创建循环队列

    QueueInit(&Q); //初始化循环队列

 

    G->isTrav[k]=1; //标记该顶点

    printf("->%c",G->Vertex[k]);  //输出第一个顶点

 

    //添加处理节点的操作

    QueueIn(&Q,k); //入队列

    while (!QueueIsEmpty(Q)) //队列不为空

    {

        QueueOut(&Q,&i); //出队列

        for (j=0;j<G->VertexNum;j++)

            if(G->Edges[i][j]!=MAXVALUE && !G->isTrav[j])

            {

                printf("->%c",G->Vertex[j]);

                G->isTrav[j]=1;  //标记该顶点

                //处理顶点

                QueueIn(&Q,j); //出队列

            }

    }

}

 

/*********************测试代码**************************/

int main()

{

    MatrixGraph G; //定义保存邻接表结构的图

    int path[VERTEX_MAX];

    int i,j,s,t;

    char select;

    do

    {

        printf("输入生成图的类型(0:无向图,1:有向图):");

        scanf("%d",&G.GraphType); //图的种类

        printf("输入图的顶点数量和边数量:");

        scanf("%d,%d",&G.VertexNum,&G.EdgeNum); //输入图顶点数和边数

        for(i=0;i<G.VertexNum;i++)  //清空矩阵

            for(j=0;j<G.VertexNum;j++)

                G.Edges[i][j]=MAXVALUE; //设置矩阵中各元素的值为0        

        CreateMatrixGraph(&G); //生成邻接表结构的图

        printf("邻接矩阵数据如下:\n");

        OutMatrix(&G); //输出邻接矩阵            

        DFSTraverse(&G); //深度优先搜索遍历图

        BFSTraverse(&G); //广度优先搜索遍历图

        printf("图遍历完毕，继续进行吗?(Y/N)");

        scanf(" %c",&select);

    }while(select!='N' && select!='n');   

    getch();

    return 0;

}

 

求最小生成树：

1、Prim算法

#define USED 0    //已使用，加入U集合

#define NOADJ -1  //非邻接顶点

void Prim(MatrixGraph G)//最小生成树

{

    int i,j,k,min,sum=0;

    int weight[VERTEX_MAX];//权值

    char tmpvertex[VERTEX_MAX];//临时顶点信息

   

    for(i=1;i<G.VertexNum;i++) //保存邻接矩阵中的一行数据                                                                                                      

    {

        weight[i]=G.Edges[0][i]; //权值

        if(weight[i]==MAXVALUE)

            tmpvertex[i]=NOADJ; //非邻接顶点

        else

            tmpvertex[i]=G.Vertex[0]; //邻接顶点

    }

    tmpvertex[0]=USED; //将0号顶点并入U集

    weight[0]=MAXVALUE; //设已使用顶点权值为最大值

    for(i=1;i<G.VertexNum;i++)

    {

        min=weight[0]; //最小权值

        k=i;

        for(j=1;j<G.VertexNum;j++) //查找权值最小的一个邻接边

            if(weight[j]<min && tmpvertex[j]>0) //找到具有更小权值的未使用边

            {

                min=weight[j]; //保存权值

                k=j; //保存邻接点序号

            }

        sum+=min;//累加权值

        printf("(%c,%c),",tmpvertex[k],G.Vertex[k]); //输出生成树一条边

        tmpvertex[k]=USED; //将编号为k的顶点并入U集

        weight[k]=MAXVALUE; //已使用顶点的权值为最大值

        for(j=0;j<G.VertexNum;j++) //重新选择最小边

            if(G.Edges[k][j]<weight[j] && tmpvertex[j]!=0)

            {

                weight[j]=G.Edges[k][j]; //权值

                tmpvertex[j]=G.Vertex[k]; //上一个顶点信息

            }

    }

    printf("\n最小生成树的总权值为:%d\n",sum);

}

 

/********************测试代码************************/

#include "3-6 AdjMatrixGraph.c"

#include "3-12 Prim.c"

int main()

{

    MatrixGraph G; //定义保存邻接表结构的图

    int path[VERTEX_MAX];

    int i,j,s,t;

    char select;

    do

    {

        printf("输入生成图的类型(0:无向图,1:有向图):");

        scanf("%d",&G.GraphType); //图的种类

        printf("输入图的顶点数量和边数量:");

        scanf("%d,%d",&G.VertexNum,&G.EdgeNum); //输入图顶点数和边数

 

        for(i=0;i<G.VertexNum;i++)  //清空矩阵

            for(j=0;j<G.VertexNum;j++)

                G.Edges[i][j]=MAXVALUE; //设置矩阵中各元素的值为0        

        CreateMatrixGraph(&G); //生成邻接表结构的图

        printf("邻接矩阵数据如下:\n");

        OutMatrix(&G);       

 

        printf("最小生成树的边为:\n");

        Prim(G);

 

        printf("继续进行吗?(Y/N)");

        scanf(" %c",&select);

        getchar();

    }while(select!='N' && select!='n');

    getch();

    return 0;

}

 

2、Dijkstra算法

void Dijkstra(MatrixGraph G)

{

    int weight[VERTEX_MAX];//某源点到各顶点的最短路径长度

    int path[VERTEX_MAX];//某源点到终点经过的顶点集合的数组

    int tmpvertex[VERTEX_MAX];//最短路径的终点集合

    int i,j,k,v0,min;

    printf("\n请输入源点的编号:");

    scanf("%d",&v0);

    v0--; //编号自减1(因数组是从0开始)

    for(i=0;i<G.VertexNum;i++) //初始辅助数组

    {

        weight[i]=G.Edges[v0][i]; //保存最小权值

        if(weight[i]<MAXVALUE && weight[i]>0) //有效权值

            path[i]=v0; //保存边

        tmpvertex[i]=0; //初始化顶点集合为空

    }

    tmpvertex[v0]=1; //将顶点v0添加到集合U中

    weight[v0]=0; //将源顶点的权值设为0

    for(i=0;i<G.VertexNum;i++)

    {

        min=MAXVALUE; //将min中保存一个最大值

        k=v0; //源顶点序号

        for(j=0;j<G.VertexNum;j++) //在U集合中查找未用顶点的最小权值                                                                             

            if(tmpvertex[j]==0 && weight[j]<min)

            {

                min=weight[j];

                k=j;

            }

        tmpvertex[k]=1;   //将顶点k加入集合U

        for(j=0;j<G.VertexNum;j++) //以顶点k为中间点，重新计算权值

            if(tmpvertex[j]==0 && weight[k]+G.Edges[k][j]<weight[j]) //有更小权值的路径

            {

                weight[j]=weight[k]+G.Edges[k][j]; //更新权值

                path[j]=k;

            }

    }

    printf("\n顶点%c到各顶点的最短路径为(终点 < 源点):\n",G.Vertex[v0]);

    for(i=0;i<G.VertexNum;i++)//输出结果

    {

        if(tmpvertex[i]==1)

        {

            k=i;           

            while(k!=v0)

            {

                j=k;

                printf("%c < ",G.Vertex[k]);

                k=path[k];

            }

            printf("%c\n",G.Vertex[k]);

        }else

            printf("%c<-%c:无路径\n",G.Vertex[i],G.Vertex[v0]);

    }

}

 

/********************测试代码**********************/

#include <stdio.h>

#include "3-6 AdjMatrixGraph.c"

#include "3-14 Dijkstra.c"

int main()

{

    MatrixGraph G; //定义保存邻接表结构的图

    int path[VERTEX_MAX];

    int i,j,s,t;

    char select;

    do

    {

        printf("输入生成图的类型(0:无向图,1:有向图):");

        scanf("%d",&G.GraphType); //图的种类

        printf("输入图的顶点数量和边数量:");

        scanf("%d,%d",&G.VertexNum,&G.EdgeNum); //输入图顶点数和边数

 

        for(i=0;i<G.VertexNum;i++)  //清空矩阵

            for(j=0;j<G.VertexNum;j++)

                G.Edges[i][j]=MAXVALUE; //设置矩阵中各元素的值为0        

        CreateMatrixGraph(&G); //生成邻接表结构的图

        printf("邻接矩阵数据如下:\n");

        OutMatrix(&G);       

 

        printf("最短路径:\n");

        Dijkstra(G);

 

        printf("继续进行吗?(Y/N)");

        scanf(" %c",&select);

        getchar();

    }while(select!='N' && select!='n');

    getch();

    return 0;

}


/*****************************************Java实现图******************************/

Java实现连接矩阵存储结构的图

package com.jtlyuan.graph;

publicclass MGraph {

    publicstaticintVERTEX_MAX = 25;

    char[] Vertex = newchar[VERTEX_MAX]; // 保存顶点信息(序号或字母)

    int[][] Edges = newint[VERTEX_MAX][VERTEX_MAX]; // 保存边的权                                                                              

    boolean[] isTrav = newboolean[VERTEX_MAX]; // 遍历标志

    intVertexNum; // 顶点数量

    intEdgeNum;// 边数量

    publicchar[] getVertex() {

       returnVertex;

    }

    publicvoid setVertex(char[] vertex) {

       Vertex = vertex;

    }

    publicint[][] getEdges() {

       returnEdges;

    }

    publicvoid setEdges(int[][] edges) {

       Edges = edges;

    }

    publicint getVertexNum() {

       returnVertexNum;

    }

    publicvoid setVertexNum(int vertexNum) {

       VertexNum = vertexNum;

    }

    publicint getEdgeNum() {

       returnEdgeNum;

    }

    publicvoid setEdgeNum(int edgeNum) {

       EdgeNum = edgeNum;

    }

}

 

深度优先遍历和广度优先遍历

package com.jtlyuan.graph;

 

import java.util.LinkedList;

import java.util.Queue;

 

publicclass GraphTraDemo {

    /****深度优先遍历******/

    publicvoid DFSTra(MGraph g){

       for(int i=0;i<g.VertexNum;i++){

           g.isTrav[i]=false;

       }

       for(int i =0 ;i<g.VertexNum;i++){                                                                                                                

           if(!g.isTrav[i]){

              DFS(g,i);

           }

       }

    }

    privatevoid DFS(MGraph g, int i) {

       g.isTrav[i]=true;

       System.out.print(g.Vertex[i]+ " --> ");

       for(int j = 0; j<g.VertexNum;j++){

           if(g.Edges[i][j]!=0&&!g.isTrav[j]){

              DFS(g,j);

           }

       }

    }

    /******广度优先遍历*********/

    publicvoid BFSTra(MGraph g){

       for(int i=0;i<g.VertexNum;i++){

           g.isTrav[i]=false;

       }

       for(int i =0 ;i<g.VertexNum;i++){

           if(!g.isTrav[i]){

              BFS(g,i);

           }

       }

    }

    privatevoid BFS(MGraph g, int i) {

       Queue<Integer> q = new LinkedList<Integer>();

       q.add(i);

       g.isTrav[i]=true;

       System.out.print(g.Vertex[i]+"-->");

 

       while(!q.isEmpty()){

           q.poll();

           for(int j = 0 ;j<g.VertexNum;j++){

              if(g.Edges[i][j]!=0&&!g.isTrav[j]){

                  System.out.print(g.Vertex[j]+"-->");

                  g.isTrav[j]=true;

                  q.add(j);

              }

           }

       }

    }

    publicstaticvoid main(String[] args) {

       MGraph g = new MGraph();

       g.setVertexNum(5);

       g.setEdgeNum(6);

       g.Vertex[0]='A';

       g.Vertex[1]='B';

       g.Vertex[2]='C';

       g.Vertex[3]='D';

       g.Vertex[4]='E';

       g.Edges[0][1]=3;

       g.Edges[0][3]=2;

       g.Edges[1][2]=9;

       g.Edges[2][4]=7;

       g.Edges[3][4]=6;

       g.Edges[4][1]=3;

       System.out.println("深度遍历");

       new GraphTraDemo().DFSTra(g);

       System.out.println("\n广度遍历");

       new GraphTraDemo().BFSTra(g);

    }

}

/*打印了

深度优先遍历

A --> B --> C --> E --> D -->

广度优先遍历

A-->B-->D-->C-->E-->

*/

 


jtlyuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论随笔(七)：图(Graph)的表示(附Python实现源码)
天降风云的博客
08-29 1204
与树类似，图也是计算机算法领域的一个重要的数据结构。很多经典问题的算法都是基于图实现的，例如最大流(Max-Flow)、最小生成树(MST)等等。这些经典问题在今后的文章中都会提到。今天这篇文章，主要介绍图的定义、有关图的一些术语和图的特性。 1. 图(Graph)的定义 在计算机理论中，图可以表示为 G=(V,E) G = (V, E) G=(V,E) 其中V是一组节点的集合，称作顶点(vertices)，E是一个集合，集合中每一个元素是一对顶点(pair of vertices)，称作边(edge)。以
HTML背景图片的设置
weixin_43183219的博客
01-05 3万+
背景图片的设置，背景图片大小、位置、是否重复以及附着点的问题
计算机图形学定义
AlZhuo的博客
07-07 894
1.在计算机上生成图形的工具 2.与图形交互的工具 3.快速绘制图形的硬件 4.图形真实感的显示 5.仿真物理现象的算法 6.可视化复杂数学的工具 计算机图形学 -对非图形信息产生图形 模式识别 -对图像提取特征，予以分类和描述关系，再进行匹配（比如识别文字，土，干，都是两横一竖的特征） 图像处理 -对图像采用增强，变换等技术进行处理 -增强对比度：对曝光过度，不足，或模糊的进行处理 -变换：一幅亮度范围宽的图像->两种亮度的图像->线条状图形 C.G. 描述-.
数据结构与算法——29. 图（Graph）的概念及应用
花城的博客
12-08 2405
文章目录一、图（Graph）的概念1. 图的相关术语2. 图的定义二、图抽象数据类型（ADT Graph）1. 邻接矩阵实现图2. 邻接列表实现图3. python代码实现三、图的应用：词梯问题1. 构建单词关系图2. python代码实现 一、图（Graph）的概念 图Graph是比树更为一般的结构，也是由节点和边构成。而实际上树是一种具有特殊性质的图。 图可以用来表示现实世界中很多事物：道路交通系统、航班线路、互联网连接、或者是大学中课程的先修次序。 一旦我们对图相关问题进行了准确的描述，就可以采用处
怎样找一张图片的原图、出处？最全搜图网站+具体案例分享
热门推荐
阿虚同学的博客
07-04 39万+
前不久随手帮一网友找了张图，想了想中间的经历挺有意思，所以今天打算来说说以图搜图这个话题 第一部分，先介绍常用的识图引擎 第二部分，想分享一下阿虚自己的搜图经验，也是今天主要想分享的。 ▍1 首先推荐几个识图引擎 一样，识图这个东西，没有哪个引擎最强一说， 每个引擎的算法不同，基于的数据库不同，对不同图片的搜索效果也不同。 所以如果想掌握搜图这个东西的话，一定得用上多个识图引擎。 不过总得来说优先度大体从上至下（部分识图引擎效果不好，下面就不介绍了） ● 1.1 谷歌识图（被墙） 网址：https:/.
[LaTex] 如何插入多个图片及子图片（subfigure）
徐心兰
04-12 7万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、插入多个图片1、插入一张图片2、插入多张图片（以2×2为例）二、插入多张子图总结 一、插入多个图片 以IEEE双栏论文模板为例 以下图片的插入方式都是以IEEE双栏模板为例，图片都在单栏上。 如果使图片横穿两栏，则在 \begin{figure}\end{figure} 上加*号，即改为 \begin{figure*} \end{figure*} 包引用暂且不表，学校提供的latex论文模板已经做好了。 1、插入一张图.
Markdown：插入图片和图注
qq_32515081的博客
04-25 7530
在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,图片重复
3. LaTeX图片的排版、引用与格式
qq_41775769的博客
11-18 6万+
3. LaTeX图片的排版、引用与格式 1.LaTeX 图片排版方式   在 LaTex 排版的论文写作中，LaTex 的所有宏包文件都要写在 \documentclass 命令之后和 \begin{document} 之前。在本文中，图片排版时使用到的宏包文件有： % 引言区 \documentclass[utf-8]{article} \usepackage{ctex} \usepackage{graphicx} %% 图片包 \usepackage{subfig} %% 子图包
IDEA背景图片集
白杨
05-10 2万+
个人收集的一些比较适合IDEA背景的图片集，都是收集的动漫系列。根据自己的喜好，随时更换背景图片，换个心情敲代码吧。
Java图片上查找图片算法
01-21
　屏幕截图，得到图A，(查找的目标图片为图B)； 　遍历图A的像素点，根据图B的尺寸，得到图B四个角映射到图A上的四个点； 　得到的四个点与图B的四个角像素点的值比较。如果四个点一样，执行步骤4；否则，回到...
最全的android图片加密
11-26
在加密图片时，我们可以在原始数据中随机插入一些无关的字节，使得即使获取了加密后的数据，没有正确的“混入”规则也无法还原原图。这种方法可以进一步提高数据的安全性，防止针对AES等标准加密方式的攻击。 在...
Android 图片浏览全屏缩放
05-10
在Android开发中，实现图片浏览的全屏缩放效果是一项常见的需求，特别是在社交应用中，如QQ好友动态和微信朋友圈。这种功能不仅需要提供良好的用户体验，还需要考虑性能和内存优化，因为图片通常较大，处理不当可能...
C# winform 图片定位 图片相似度匹配 查询图1在图2中的位置
05-06
图片定位主要是确定一张小图片（查询图）在大图片（背景图）中的精确位置。通常，这涉及到图像特征匹配、模板匹配或基于深度学习的方法。在WinForm应用中，我们可以使用OpenCV库，这是一个强大的跨平台计算机视觉库...
c#生成自定义图片方法代码实例
08-26
在远程缩略图的生成中，我们使用 URL 来获取图片，然后使用 SaveImage 方法来保存缩略图。 通过本篇文章，读者可以了解如何使用 C# 语言来生成自定义图片，并掌握相关的编程技术。这将有助于读者更好地掌握 C# 语言...
2012腾讯实习笔试中看到的Catalan数
04-09 1万+
卡特兰数：规定C0＝1，而C1＝1，C2＝2，C3＝5，C4＝14，C5＝42，C6＝132，C7＝429，C8＝1430，C9＝4862，C10＝16796， C11＝58786，C12＝208012，C13＝742900，C14＝2674440，C15＝9694845········································· 卡塔兰数的一般项公式为
编程之美：计算两个字符串的相似度---动态规划实现
04-12 8288
问题描述： 把两个字符串变成相同的基本操作定义如下： 1.     修改一个字符（如把 a 变成 b） 2.     增加一个字符 (如 abed 变成 abedd) 3.     删除一个字符（如 jackbllog 变成 jackblog） 针对于 jackbllog到jackblog 只需要删除一个或增加一个 l 就可以把两个字符串变为相同。把这种操作需要的次数定义为两个字符串的距
编程之美--发帖水王
03-29 8057
转载：http://blog.csdn.net/v_july_v/article/details/6890054 第二十一~二十二章：出现次数超过一半的数字，最短摘要的生成     第一个问题来自编程之美上，Tango是微软亚洲研究院的一个试验项目，如图1所示。研究院的员工和实习生们都很喜欢在Tango上面交流灌水。传说，Tango有一大
《算法导论》中动态规划习题15-6--在棋盘上移动
07-18 7011
问题描述：假设有一张n*n个方格的棋盘以及一个棋子，必须根据以下的规则把棋子从棋盘的底边移动到棋盘的顶边，在每一步你可以把棋子移动到三个方格中的一个： 1、正上方的方格。 2、左上方的方格（只能当这个棋子不在最左列的时候） 3、右上方的方格（只能当这个棋子不在最右列的时候） 每次从方格x移动到方格y，会得到p（x,y）块钱。已知所有（x,y）的p（x,y），只要从x到y的移动是合法的。不要
C#图片处理：生成清晰缩略图与裁剪、水印技巧
C#.NET 图片处理的基本应用，包括提高缩略图清晰度、图片裁剪以及图片水印的实现。 在C#.NET中处理图片是一项常见的任务，尤其在开发涉及图像展示的应用时，如相册功能。用户上传的图片通常需要进行一系列处理，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值