数据结构最短路径

dijkstra

DS图—图的最短路径（不含代码框架）

题目描述
给出一个图的邻接矩阵，输入顶点v，用迪杰斯特拉算法求顶点v到其它顶点的最短路径。

输入
第一行输入t，表示有t个测试实例

第二行输入顶点数n和n个顶点信息

第三行起，每行输入邻接矩阵的一行，以此类推输入n行

第i个结点与其它结点如果相连则为距离，无连接则为0，数据之间用空格

隔开。第四行输入v0，表示求v0到其他顶点的最短路径距离

以此类推输入下一个示例

输出
对每组测试数据，输出：

每行输出v0到某个顶点的最短距离和最短路径

每行格式：v0编号-其他顶点编号-最短路径值----[最短路径]。没有路径输出：v0编号-其他顶点编号–1。具体请参考示范数据

样例输入
2
5 0 1 2 3 4
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0
6 V0 V1 V2 V3 V4 V5
0 0 10 0 30 100
0 0 5 0 0 0
0 0 0 50 0 0
0 0 0 0 0 10
0 0 0 20 0 60
0 0 0 0 0 0
V0
样例输出
0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]
V0-V1–1
V0-V2-10----[V0 V2 ]
V0-V3-50----[V0 V4 V3 ]
V0-V4-30----[V0 V4 ]
V0-V5-60----[V0 V4 V3 V5 ]

#include <iostream>
#include <map>
#include <stack>

using namespace std;

const int maxn = 105;
const int INF = 0x3f3f3f3f;

int Graph[maxn][maxn];

int n;

map<string, int> name;

bool vis[maxn];

int dis[maxn];

int from[maxn];

void init()
{
    
    for(int i = 0; i < maxn; i++)
    {
        vis[i] = false;
        dis[i] = INF;
        from[i] = i;
        for(int j = 0; j < maxn; j++)
            Graph[i][j] = INF;
    }
    name.clear();
}

string getname(int i)
{
    for(map<string, int>::iterator it = name.begin(); it != name.end(); it++)
        if(it -> second == i)
            return it -> first;
}

void dijkstra(int s)
{
    vis[s] = true;
    
    for(int i = 0; i < n; i++)
        if(Graph[s][i] != INF)
            dis[i] = Graph[s][i], from[i] = s;
    
    for(int N = 1; N < n; N++)
    {
        int minn = INF, mini = -1;
        for(int i  = 0; i < n; i++)
            if(!vis[i] && dis[i] < minn)
                minn = dis[i], mini = i;
        
        if(mini != -1)
        {
            vis[mini] = true;
            
            for(int i = 0; i < n; i++)
                if(!vis[i] && dis[i] > Graph[mini][i] + dis[mini])
                    dis[i] = Graph[mini][i] + dis[mini], from[i] = mini;
        
        }
    }
    
    for(int i = 0; i < n; i++)
    {
        if(s == i)
            continue;
        
        cout << getname(s) << "-" << getname(i);
        
        if(dis[i] == INF)
            cout << "--1";
        else
        {
            int now = i;
            stack<int> ss;
            while(now != from[now])
            {
                ss.push(now);
                now = from[now];
            }
            cout << "-" <<  dis[i] << "----[" << getname(s) << ' ';
            while(!ss.empty())
            {
                cout << getname(ss.top()) << ' ';
                ss.pop();
            }
            cout <<"]" ;
        }
        cout << endl;
    }
    
}

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        init();
        
        cin >> n;
        string s;
        
        for(int i = 0; i < n; i++)
        {
            cin >> s;
            name[s] = i;
        }
        
        for(int i = 0; i < n; i++)
            for(int j = 0, x; j < n;  j++)
            {
                cin >> x;
                if(x)
                    Graph[i][j] = x;
            }
        cin >> s;
        dijkstra(name[s]);
        
    }
}

Floeyd

题目描述
给定有向图的邻接矩阵A，其元素定义为：若存在顶点i到顶点j的有向边则A[i,j]=1，若没有有向边则A[i,j]= 0。试求A的可达闭包矩阵A*，其元素定义为：若存在顶点i到顶点j的有向路径则A*[i,j]=1，若没有有向路径则A*[i,j]= 0。

输入
第1行顶点个数n

第2行开始的n行有向图的邻接矩阵，元素之间由空格分开

输出
有向图的可达闭包矩阵A*，元素之间由空格分开

样例输入
4
0 1 0 1
0 0 1 0
0 0 0 0
0 0 0 0
样例输出
0 1 1 1
0 0 1 0
0 0 0 0
0 0 0 0

#include <iostream>

using namespace std;

const int maxn = 105;

int Graph[maxn][maxn];

int main()
{

    int n;
    cin >> n;
    
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            cin >> Graph[i][j];
        
    for(int k = 0; k < n; k++)
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                Graph[i][j] = Graph[i][k] && Graph[k][j] ? 1 : Graph[i][j];
    
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(j)
                cout << ' ';
            cout << Graph[i][j];
        }
        cout << endl;
    }

}