算法习题37：有n个长为m+1的字符串， 如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接

有n个长为m+1的字符串，
如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接，

问这n个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。

----------------------------------------------------------------------------------------------------------------

一开始看到这题目，会先想到直接去比较，比如给定str1,str2,str3这几个字符串，如何找他们链接长度最长呢？

检查

str1-->str1  str1-->str2   str1-->str3   

str2-->str1  str2-->str2   str2-->str3   

.。。。

如果链接上了还要在找链接上的字符串和其他比较，这是一个很可怕的比较过程

其实比较的过程会让我们想到，这就是在需要一个最长的链接方式，熟悉图论的淫会想到，这就是在找最长路径，而路径之间的权值不过是0和1罢了，就是能否到达。

所以这道题就变成了图论问题。

当然最先想到就是Dijkstra和Floyd这些算法，虽然他们一般是用来找最短路径，当然最长路径可以用上，转换下找长的就可以。

我这里用一个递归实现，就是深度搜索，如果搜索距离大于总长度，则存在环。。

硬伤：最后必须delete所有new出来的空间!!!

上网搜了下，大家都是这样做的，他们大都用到了Floyd算法，大家可以参照他们的具体过程

//============================================================================
// Name        : StrLink.cpp
// Author      : YLF
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

bool StrLink(char** strs, int size);
bool Link(int** matrix, int size, int src, int* queue, int index);
bool LinkTo(char* src, char* dst);

void Print(int** matrix, int size);
void Print(char** matrix, int size);


int maxIndex = 0;
int result[100];

int main() {
	//输入字符串个数
	int size = 0;
	cin>>size;

	//输入m+1
	int M = 0;//M = m+1;
	cin>>M;

	int i = 0;
	char** strs = new char*[size];
	for(i=0;i<size;i++){
		strs[i] = new char[M+1];//空结尾
		cin>>strs[i];
		strs[i][M]='\0';
	}
	Print(strs, size);

	if(StrLink(strs,size)){
		int temp = 0;
		cout<<maxIndex<<" str: ";
		for(temp=0;temp<maxIndex;temp++)
			cout<<strs[result[temp]]<<"-->";
	}
	else
		cout<<"存在环";
	return 0;
}

bool StrLink(char** strs, int size){
	int i=0, j=0;
	int **matrix = new int*[size];
	for(i=0;i<size;i++){
		matrix[i] = new int[size];
		for(j=0;j<size;j++)
			matrix[i][j] = 0;
	}

	for(i=0;i<size;i++){
		for(j=0;j<size;j++){
			if(LinkTo(strs[i],strs[j]))
				matrix[j][i] = 1;
		}
	}

	Print(matrix, size);
	//接下来转换成图问题
	int *queue = new int[size];
	int index = 0;
	for(i=0;i<size;i++){
		index=0;
		queue[index++] = i;
		if(Link(matrix, size, i, queue, index) == false)
			return false;
	}
	return true;
}

/*
 * 这里递归，深度搜索
 */
bool Link(int** matrix, int size, int src, int* queue, int index){
	int i=0;

	if(index == size)
		return false;//存在环

	for(i=0;i<size;i++){
		if(matrix[i][src] == 1){
			//链接上，增加queue
			queue[index++] = i;
			if(index>maxIndex){
				maxIndex = index;
				int temp = 0;
				for(temp=0;temp<maxIndex;temp++)
					result[temp] = queue[temp];
			}
			//循环深度搜索
			if(Link(matrix, size, i, queue, index) == false)
				return false;
			//返回的时候index--
			index--;
		}
	}
	return true;
}

/*
 * 比较两字符串是否能链接上
 */
bool LinkTo(char* src, char* dst){
	int i = 0;
	int len = strlen(dst);
	char* temp = new char[len];
	for(i=0;i<len-1;i++)
		temp[i] = dst[i];
	temp[i] = '\0';

	//cout<<"cmp:"<<src+1<<" "<<temp<<endl;
	if(strcmp(src+1,temp) == 0)
		return true;
	else
		return false;
}

void Print(int** matrix, int size){
	int i=0, j=0;
	for(i=0;i<size;i++){
		for(j=0;j<size;j++){
			cout<<matrix[i][j]<<" ";
		}
		cout<<endl;
	}
}

void Print(char** matrix, int size){
	int i=0;
	for(i=0;i<size;i++){
		cout<<matrix[i]<<endl;
	}
}

8
4
dcba cbab babc abcd bcde cdea deab eabc
dcba
cbab
babc
abcd
bcde
cdea
deab
eabc
0 0 0 0 0 0 0 0 
1 0 0 0 0 0 0 0 
0 1 0 0 0 0 0 0 
0 0 1 0 0 0 0 1 
0 0 0 1 0 0 0 0 
0 0 0 0 1 0 0 0 
0 0 0 0 0 1 0 0 
0 0 0 0 0 0 1 0 
存在环

比较粗糙的打印。。

4
4
abcd abce bcde babc
abcd
abce
bcde
babc
0 0 0 1 
0 0 0 1 
1 0 0 0 
0 0 0 0 
3 str: babc-->abcd-->bcde-->