考研数据结构之最短路径、字符匹配

BFS

设计算法能够求出连通图中任意两个指定顶点之间的一条路径长度最短的路径

完整代码

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define n 5
int a[n][n];
int d[n];
bool visit[n];
int save[n];
void bfs(int u,int v,int a[][n])
{
    memset(d,0,sizeof d);
    d[u]=0;
    visit[u]=true;
    int top=0;
    save[top++]=u;
    while(top!=0)
    {
        int x=save[--top];

        if(x==v)
            break;
        for(int i=0;i<n;i++)
        {
            if(!visit[i]&&a[x][i]==1)
            {
                visit[i]=true;
                d[i]=d[x]+1;
                save[top++]=i;
            }
        }
    }
        cout<<d[v]<<endl;

}
int main()
{   memset(a,0,sizeof a);
    int u,v;
    cin>>u>>v;
    int q,w;
    for(int i=0;i<n;i++)
    {
        cin>>q>>w;
        a[q][w]=1;
        a[w][q]=1;
    }
    bfs(u,v,a);
    return 0;
}

试卷展示模块

void bfs(int u,int v,int a[][n])
{
    memset(d,0,sizeof d);
    d[u]=0;//从u到i的路径长度
    visit[u]=true;
    int top=0;
    save[top++]=u;
    while(top!=0)
    {
        int x=save[--top];

        if(x==v)
            break;
        for(int i=0;i<n;i++)
        {
            if(!visit[i]&&a[x][i]==1)
            {
                visit[i]=true;
                d[i]=d[x]+1;
                save[top++]=i;
            }
        }
    }
        printf("从x到y的最短路径是:%d\n",d[y]);
}

Dijkstra

#include <stdio.h>
#include <stdlib.h>
#define INF 10e9
//Dijkstra
int main()
{
    void Dijkstra(Graph G, int vs, int prev[], int dist[])
    {
        int i,j,k;
        int min;
        int tmp;
        int flag[MAX];
        // flag[i]=1 表示"顶点 vs"到"顶点 i"的最短路径已成功
        for (i = 0; i < G.vexnum; i++)
        {
            // 初始化
            flag[i] = 0;
            prev[i] = 0;
            dist[i] = G.matrix[vs][i];// 顶点 i 的最短路径为"顶点 vs"到"顶点 i"的权.
                                        // 顶点 i 的最短路径还没获取到.//顶点 i 的前驱顶点为 0.
        }
        // 对"顶点 vs"自身进行初始化
        flag[vs] = 1;
        dist[vs] = 0;
        // 遍历 G.vexnum-1 次;每次找出一个顶点的最短路径.
        for (i = 1; i < G.vexnum; i++)
        {
            // 寻找当前最小的路径;
            // 即,在未获取最短路径的顶点中，找到离 vs 最近的顶点(k).
            min = INF;
            for (j = 0; j < G.vexnum; j++)
            {
                if (flag[j]==0 && dist[j]<min)
                {
                    min = dist[j];
                    k = j;
                }
            }
        // 标记"顶点 k"为已经获取到最短路径
            flag[k] = 1;
        // 修正当前最短路径和前驱顶点
        // 即,当已经"顶点 k 的最短路径"之后，更新"未获取最短路径的顶点 的最短路径和前驱顶点.

            for (j = 0; j < G.vexnum; j++)
            {

            tmp = (G.matrix[k][j]==INF ? INF : (min + G.matrix[k][j])); // 防止溢

            if (flag[j] == 0 && (tmp < dist[j]) )
                {
                    dist[j] = tmp;
                    prev[j] = k;
                }

            }

        }

            // 打印 dijkstra 最短路径的结果
            printf("从x到x的最短路径是:%d\n",dist[x]);
    }
            return 0;

字符匹配

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i;
    int flag;
    char s[51],a[51];
    char k;
    flag=-1;
    int w=1;
    gets(s);
    for(i=0; s[i]!='\0'; i++)
    {
        if(s[i]=='{'||s[i]=='['||s[i]=='(')
        {
            a[++flag]=s[i];
        }
        if(s[i]=='}'||s[i]==']'||s[i]==')')
        {
            k=a[flag];
            flag--;
            if((s[i]=='}'&&k=='{')||(s[i]==']'&&k=='[')||(s[i]==')'&&k=='('))
            {
            }
            else
                break;
        }
        if(flag==-1&&s[i]=='\0')
        {
            printf("匹配成功\n");
        }
        else
            printf("匹配失败\n");

    }

    return 0;
}

三级目录