有n 个长为m+1 的字符串，求前后m个字符匹配所能形成的最长字符串链：利用弗洛伊德算法求最长路径

有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接，问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。

把字符串看成图中的一个顶点，两字符串匹配则两个顶点间有边，从而转化为图的问题。

利用弗洛伊德算法求图的最长路径。

#include <iostream>
#include <string>
using namespace std;

#define INFINITY -10000
#define MAX_VERTEX_NUM 20

typedef struct MGraph{
    string vexs[MAX_VERTEX_NUM];//顶点信息，这里就是要处理的字符串，每个字符串看做一个顶点
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//邻接矩阵，符合条件的两个字符串之间有边
    int vexnum, arcnum;//顶点数就是字符串的个数
}MGraph;

void CreateDG(MGraph &G)//构造有向图
{
    int i, j;
    int m;
    cout<<"请输入要处理的字符串个数：";
    cin>>G.vexnum;

    cout<<"请输入这"<<G.vexnum<<"个字符串：";
    for(i=0; i<G.vexnum; i++)
        cin>>G.vexs[i];

    cout<<"请输入m：";
    cin>>m;

    for(i=0; i<G.vexnum; i++)
        for(j=0; j<G.vexnum; j++)
        {
            if(G.vexs[i].substr(G.vexs[i].size()-m,m)==G.vexs[j].substr(0,m))//根据前后m个字符是否匹配确定两字符串之间是否有边
                G.arcs[i][j]=1;
            else
                G.arcs[i][j]=INFINITY;
        }
}

//利用弗洛伊德算法求各顶点间的最长路径，p保存路径，D保存各顶点间的最长路径，如果出现循环，函数返回false，反之返回true
bool Largeset_FLOYD(MGraph G, int p[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM], int D[MAX_VERTEX_NUM][MAX_VERTEX_NUM])
{
    int v, w, u;
    int i, j;

    for(v=0; v<G.vexnum; v++)
        for(w=0; w<G.vexnum; w++)
        {
            D[v][w]=G.arcs[v][w];
            for(u=0; u<G.vexnum; u++)
                p[v][w][u]=-1;
            if(D[v][w]>INFINITY)
            {
                p[v][w][0]=v;
                p[v][w][1]=w;
            }
        }

    for(u=0; u<G.vexnum; u++)
        for(v=0; v<G.vexnum; v++)
            for(w=0; w<G.vexnum; w++)
            {
                if(D[v][u]>INFINITY && D[u][w]>INFINITY && D[v][u]+D[u][w]>D[v][w] )//改进的弗洛伊德算法，求最长路径
                {
                    D[v][w]=D[v][u]+D[u][w];

                    //更新p，以便打印路径
                    for(i=0; i<G.vexnum; i++)
                    {
                        if(p[v][u][i]!=-1)
                            p[v][w][i]=p[v][u][i];
                        else
                            break;
                    }
                    for(j=1; j<G.vexnum; j++)
                    {
                        if(p[u][w][j]!=-1)
                            p[v][w][i++]=p[u][w][j];
                        else
                            break;
                    }

                }
            }

    //判断是否有循环
    for(v=0; v<G.vexnum; v++)
        if(D[v][v]!=INFINITY)
                return false;

    return true;
}

void main()
{
    int i, j;
    int posx, posy;
    MGraph g;
    CreateDG(g);

    int p[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int D[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    bool flag=true;

    flag=Largeset_FLOYD(g, p, D);

/*  for(i=0; i<g.vexnum; i++)
    {
        for(j=0; j<g.vexnum; j++)
            cout<<D[i][j]<<" ";
        cout<<endl;
    }*/


    if(flag)
    {
        cout<<"最大长度为：";
        int max=-10000;
        for(i=0; i<g.vexnum; i++)
            for(j=0; j<g.vexnum; j++)
            {
                if(D[i][j]>max)
                {
                    max=D[i][j];
                    posx=i;
                    posy=j;
                }
            }
        cout<<max<<endl;
        cout<<"字符串链为：";
        for(i=0; i<g.vexnum; i++)//打印字符串链
        {
            if(p[posx][posy][i]!=-1)
                cout<<g.vexs[p[posx][posy][i]]<<" ";
        }
        cout<<endl;
    }
    else
        cout<<"错误：出现循环"<<endl;

}