这篇博客分享了作者参加2017中兴算法挑战赛的经历，主要探讨了使用迪杰斯特拉算法解决最强大脑风格的蚁巢迷宫路径寻找问题。题目要求在满足特定条件（最少花费、最多经过9个储藏间、必须经过特定节点等）下找到最优路径。作者提出贪心算法结合模拟退火算法的解决方案，并提供了不同规模样例的运行结果。
和刚刚结束的2017华为软件精英挑战赛相比，中兴的题目不难，花了两天时间随便搞了一下（其实也没多长时间，因为是周末，还打了农药
），没什么意思，结果刚刚揭晓，58分，评价是“算法尚可，代码一般”，GG，写的太水，大佬莫笑~
赛题：
最强大脑中的收官蜂巢迷宫变态级挑战，相信大家都叹为观止！最强大脑收官战打响后，收视率节节攀升，就连蚁后也不时出题难为一下她的子民们。在动物世界中，称得上活地图的，除了蜜蜂，蚂蚁当仁不让。在复杂多变的蚁巢中， 蚂蚁总是能以最快、最高效的方式游历在各个储藏间（存储食物）。今天，她看完最新一期节目，又发布了一项新任务：小蚁同学，我需要玉米库的玉米，再要配点水果，去帮我找来吧。小蚁正准备出发，蚁后又说：哎呀，回来，我还没说完呢，还有若干要求如下：
1.小蚁同学，你需要尽可能以最少的花费拿到食物（附件图中路线上的数值表示每两个储物间的花费）；
2.小蚁同学，你最多只能经过9个储藏间拿到食物（包含起止两个节点，多次通过同一节点按重复次数计算）；
3.小蚁同学，你必须经过玉米间，水果间（附件图中标绿色节点）；
4.别忘了，食蚁兽也在路上活动呢，一旦与食蚁兽相遇，性命危矣！不过小蚁微信群公告已经公布了敌人信息（附件图中标红色路段）；
5.最后，千万别忘了，还有两段路是必须经过的，那里有我准备的神秘礼物等着你呢(附件图中标绿色路段)。
这下小蚁犯难了，这和它们平时找食物的集体活动规则不一样嘛,看来这次需要单独行动了。要怎么选路呢？小蚁经过一番苦思冥想，稿纸堆了一摞，啊，终于找到了！亲爱的同学们，你们能否也设计一种通用的路径搜索算法，来应对各种搜索限制条件，找到一条最优路径，顺利完成蚁后布置的任务呢？
注：
1、蚁巢，有若干个储藏间（附件图中圆圈表示），储藏间之间有诸多路可以到达(各储藏间拓扑图见附件);
2、节点本身通行无花费；
3、该图为无向图，可以正反两方向通行，两方向都会计费，并且花费相同；
4、起止节点分别为附件图中S点和E点。
5、最优路径：即满足限制条件的路径。
算法思路：
贪心算法求解初始解+分段求解最短路+模拟退火算法逐步寻优（实践证明，对于这个对这个问题，贪心算法求出的初始解基本接近最优解，所以说这个比赛很水啦。。。。）
源代码：
/************************************************************
*
* Shortest Path Search for ZTE Fantastic Algorithm
* Author: chyeer
* Datetime: 2017-05-02
* Description: multiple constrainted shortest path search
* based on Shortested Path Faster Algorithm and
* Simulated Anneling Algorithm
*
************************************************************/
#ifndef ZTE_H
#define ZTE_H
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std; namespace pan{ const int maxn = 1001; const int INF = 1<<10; const int MAX_LINE_LEN = 50000; struct edge //edge { int to; int cost; }; struct node { int from; int to; }; extern vector
myV[maxn]; // adjacecy list used for topo structure of graph extern vector
constraints; // storage for multiple constraints extern vector
group; // storage for combination of multiple constraints extern vector
path; // storage for shortest path extern int numNode, numEdge; // vertexes, edges extern int minPath[maxn]; // shortest path extern int source[maxn]; // source[a]=b, the node before a is b extern int start, End; // srouce node, sink node extern int S, E; // Source Node: S, End Node: E extern bool inQ[maxn]; // in queue or not extern int wholeDis; // storage of the miniCost for the shortest path extern int distance; // distance between two nodes extern vector
mustPassedNode; // Node set that must be passed extern vector
> forbidPassedEdge; // Edge set that can not be passed extern vector
> mustPassedEdge; // Edge set that must be passed void LoadDataFromFile(const char* filename); // load basic graph data void loadConstraints(); // used for adding constraints void inputItial(); // input data from screen void output(int start, int end); // compute shortest path void SPFA(int start, int end); // shortest path faster algorithm void greedyAlgorithmForFindingInitialSolution(vector
& constraints, vector
& group); // greedy algorithm for finding initial solution void findInitialSolutionForSimulatedAnnealing(vector
& constraints, vector
& group); // get initial solution for simulated anneling void simulatedAnnealingForGetNewSolution(vector
& constraints, vector
& group); // get a new solution for simulated anneling void simulatedAnnealingForFindShortestPath(vector
& constraints, vector
& group); // simulated anneling algorithm void findShortestPath(vector
& group); // find shortest path void SaveDataToFile(const char* filename, const vector
& path); } #endif // ZTE_H
/************************************************************
*
* Shortest Path Search for ZTE Fantastic Algorithm
* Author: chyeer
* Datetime: 2017-05-02
* Description: multiple constrainted shortest path search
* based on Shortested Path Faster Algorithm and
* Simulated Anneling Algorithm
*
************************************************************/
#include "zte.h"
using namespace pan;
vector
pan::myV[maxn]; //adjacecy list used for topo structure of graph
vector
pan::constraints; // storage for multiple constraints
vector
pan::group; // storage for combination of multiple constraints
vector
pan::path; // storage for shortest path
int pan::numNode, pan::numEdge; //vertexes, edges
int pan::minPath[maxn]; // shortest path
int pan::source[maxn]; // source[a]=b, the node before a is b
int pan::start, pan::End; //srouce node, sink node
int pan::S, pan::E; // Source Node: S, End Node: E
bool pan::inQ[maxn]; // in queue or not
int pan::wholeDis; // storage of the miniCost for the shortest path
int pan::distance; // distance between two nodes
vector
pan::mustPassedNode; // Node set that must be passed vector
> pan::forbidPassedEdge; // Edge set that can not be passed vector
> pan::mustPassedEdge; // Edge set that must be passed void pan::LoadDataFromFile(const char *filename) { FILE *fp = fopen(filename, "r"); char *topo[MAX_LINE_LEN]; // Storage for all lines in file. if (fp == NULL) { printf("Fail to open file %s, %s.\n", filename, strerror(errno)); } printf("Open file %s OK.\n", filename); char line[MAX_LINE_LEN + 2]; unsigned int cnt = 0; // cnt: count line number of file. while (!feof(fp)) { line[0] = 0; if (fgets(line, MAX_LINE_LEN + 2, fp) == NULL) continue; if (line[0] == 0) continue; topo[cnt] = (char *)malloc(MAX_LINE_LEN + 2); strncpy(topo[cnt], line, MAX_LINE_LEN + 2 - 1); // copy file to topo. topo[cnt][MAX_LINE_LEN + 1] = 0; cnt++; } fclose(fp); printf("There are %d lines in file %s.\n", cnt, filename); int mustVertexNum, forbidEdgeNum, mustEdgeNum; int index = 0; sscanf(topo[index], "%d%d%d%d%d", &S, &E, &mustVertexNum, &forbidEdgeNum, &mustEdgeNum); index += 2; int vertex; for(int i=0; i
tmp; for(int i=0; i
>::iterator iter; for(iter=forbidPassedEdge.begin(); iter!=forbidPassedEdge.end(); iter++) { vector
::iterator it; for(it=myV[iter->first].begin(); it!=myV[iter->first].end(); it++) { if(it->to == iter->second) { //it->cost = INF; //delete forbid edge myV[iter->first].erase(it); //cout << it->to << " " << it->cost << endl; break; } } for(it=myV[iter->second].begin(); it!=myV[iter->second].end(); it++) { if(it->to == iter->first) { //it->cost = INF; // delete forbid edge myV[iter->second].erase(it); //cout << it->to << " " << it->cost << endl; break; } } } wholeDis = 0; } void pan::loadConstraints() { node tmp; tmp.from = 14; tmp.to = 13; constraints.push_back(tmp); tmp.from = 12; tmp.to = -1; constraints.push_back(tmp); tmp.from = 7; tmp.to = -1; constraints.push_back(tmp); tmp.from = 4; tmp.to = 2; constraints.push_back(tmp); vector
::iterator it; for(it=constraints.begin(); it!=constraints.end(); it++) { group.push_back(it->from); if(~it->to) group.push_back(it->to); } #if 0 for(size_t i=0; i
& constraints, vector
& group) { size_t index_out, index_in; int cost = INF; size_t location = 0; for(size_t i=0; i
::iterator itera; for(itera=constraints.begin(); itera!=constraints.end(); itera++) { group.push_back(itera->from); if(~itera->to) group.push_back(itera->to); } #if 0 for(size_t i=0; i
& constraints, vector
& group) { constraints.clear(); group.clear(); vector
::iterator iter; node tmp; for(iter=mustPassedNode.begin(); iter!=mustPassedNode.end(); iter++) { bool IN = false; for(size_t i=0; i
>::iterator it; for(it=mustPassedEdge.begin(); it!=mustPassedEdge.end(); it++) { tmp.from = it->first; tmp.to = it->second; constraints.push_back(tmp); } vector
::iterator itera; for(itera=constraints.begin(); itera!=constraints.end(); itera++) { group.push_back(itera->from); if(~itera->to) group.push_back(itera->to); } greedyAlgorithmForFindingInitialSolution(constraints, group); #if 0 for(size_t i=0; i
& constraints, vector
& group) { group.clear(); if(rand() % 2) { size_t index_x, index_y; index_x = rand() % constraints.size(); index_y = rand() % constraints.size(); while(index_x == index_y) { index_x = rand() % constraints.size(); index_y = rand() % constraints.size(); } swap(constraints[index_x], constraints[index_y]); } else { size_t index; while(1) { index = rand() % constraints.size(); if(~constraints[index].from && ~constraints[index].to) { swap(constraints[index].from, constraints[index].to); break; } } } vector
::iterator it; for(it=constraints.begin(); it!=constraints.end(); it++) { //if(rand() % 2) // swap(it->from, it->to); if(~it->from) group.push_back(it->from); if(~it->to) group.push_back(it->to); } #if 0 while(!tmp.empty()) { index = rand() % tmp.size(); tmpNode = tmp[index]; if(rand() % 2) swap(tmpNode.from, tmpNode.to); if(~tmpNode.from) group.push_back(tmpNode.from); if(~tmpNode.to) group.push_back(tmpNode.to); tmp.erase(tmp.begin()+index); } #endif #if 0 vector
::iterator iter; for(iter=group.begin(); iter!=group.end()-1; iter++) { cout << *iter << " "; } cout << *(group.end()-1) << endl; #endif } // kernel algorithm ---- Simulated Anneling Algorithm void pan::simulatedAnnealingForFindShortestPath(vector
& constraints, vector
& group) { double speed = 0.9999, T = 1000, t_min = 0.001; struct timeval t0, t1; gettimeofday(&t0, NULL); findInitialSolutionForSimulatedAnnealing(constraints, group); // find initial solution cout << "Initial cost: " << wholeDis << endl; int minCost = wholeDis; // cost of initial solution int bestCost = wholeDis; vector
bestPath(path); vector
tmpConstraints(constraints); vector
bestConstraints(constraints); vector
tmpGroup; vector
bestGroup(group); int delta; int iteration = 0; while(T > t_min) { simulatedAnnealingForGetNewSolution(tmpConstraints, tmpGroup); constraints.assign(tmpConstraints.begin(), tmpConstraints.end()); group.assign(tmpGroup.begin(), tmpGroup.end()); findShortestPath(tmpGroup); delta = wholeDis - minCost; if(delta < 0) { //cout << "better: " << endl; tmpConstraints.assign(constraints.begin(), constraints.end()); tmpGroup.assign(group.begin(), group.end()); if(wholeDis < bestCost) { bestConstraints.assign(constraints.begin(), constraints.end()); bestGroup.assign(group.begin(), group.end()); bestCost = wholeDis; //cout << "bestCost: " << bestCost << endl; } minCost = wholeDis; //if(minCost == 13) // break; } else { if((int)(exp(delta/T)*100) <= (rand() % 101)) { //cout << "worse: " << endl; tmpConstraints.assign(constraints.begin(), constraints.end()); tmpGroup.assign(group.begin(), group.end()); } } T *= speed; iteration++; if(iteration == 10) break; } gettimeofday(&t1, NULL); double timeUse = t1.tv_sec - t0.tv_sec + (t1.tv_usec - t0.tv_usec)/1000000.0; findShortestPath(bestGroup); minCost = wholeDis; bestPath.assign(path.begin(), path.end()); #if 0 int iteration = 100; while(iteration) { simulatedAnnealingForGetNewSolution(constraints, group); findShortestPath(group); //cout << "wholeDis: " << wholeDis << " " << "minCost: " << minCost << endl; if(wholeDis < minCost) { bestPath.assign(path.begin(), path.end()); minCost = wholeDis; cout << "Cost: " << minCost << endl; } iteration--; } #endif cout << "The minimum cost is: " << minCost << endl; cout << "Total vertex num: " << bestPath.size() << endl; cout << "The best path is: "; vector
::iterator it; for(it=bestPath.begin(); it!=bestPath.end()-1; it++) { cout << *it << "-->"; } cout << *it << endl; //cout << "Total iteration num: " << iteration << endl; cout << "Time elapse: " << timeUse << " s" << endl; } void pan::findShortestPath(vector
& group) { wholeDis = 0; path.clear(); if(!group.empty()) { SPFA(S, group[0]); for(size_t i=0; i
>::iterator iter; for(iter=mustPassedEdge.begin(); iter!=mustPassedEdge.end(); iter++) { if(group[i] == iter->first && group[i+1] == iter->second) { IN = true; //add path when the edge must be passed //path.push_back(group[i]); path.push_back(group[i+1]); //add cost vector
::iterator it; for(it=myV[group[i]].begin(); it!=myV[group[i]].end(); it++) { if(it->to == group[i+1]) { wholeDis += it->cost; break; } } break; } if(group[i] == iter->second && group[i+1] == iter->first) { IN = true; //add path when the edge must be passed path.push_back(group[i+1]); //path.push_back(group[i]); //add cost vector
::iterator it; for(it=myV[group[i+1]].begin(); it!=myV[group[i]].end(); it++) { if(it->to == group[i]) { wholeDis += it->cost; break; } } break; } } if(!IN) SPFA(group[i], group[i+1]); } SPFA(group[group.size()-1], E); } #if 0 cout << "Minimum Cost: " << wholeDis << endl; cout << "Path: "; vector
::iterator it; for(it=path.begin(); it!=path.end()-1; it++) { cout << *it << "-->"; } cout << *it << endl; #endif } void pan::inputItial() { int i, from, to, cost; wholeDis = 0; for(i=0; i
s; s.push(tmp); while(source[tmp]!=start) { tmp=source[tmp]; s.push(tmp); } while(!s.empty()) { //printf("-->%d",s.top()); path.push_back(s.top()); s.pop(); } //printf("\n"); //printf("Total cost : %d\n\n",minPath[end]); distance = minPath[end]; wholeDis += minPath[end]; } } void pan::SPFA(int start, int end) //Shortest Path Faster Algorithm { memset(inQ, false, sizeof(inQ)); inQ[start] = true; for(int j=0; j
myQ; myQ.push(start); int now, to, cost; while(!myQ.empty()) { now=myQ.front(); myQ.pop(); for(size_t k=0; k
cost) { source[to] = now; //record the source of to: now minPath[to] = cost; if(!inQ[to]) { inQ[to] = true; myQ.push(to); } } } inQ[now] = false; } output(start, end); } void pan::SaveDataToFile(const char *filename, const vector
& path) { fstream fs; fs.open(filename, ios_base::out); fs << path.size() << endl << endl; for(size_t i=0; i
/************************************************************
*
* Shortest Path Search for ZTE Fantastic Algorithm
* Author: chyeer
* Datetime: 2017-05-02
* Description: multiple constrainted shortest path search
* based on Shortested Path Faster Algorithm and
* Simulated Anneling Algorithm
*
************************************************************/
#include "zte.h"
#include
using namespace pan;
int main(int argc, char *argv[])
{
#if 0
freopen("C:\\Users\\Administrator\\Desktop\\case4.txt", "r+" , stdin);
while(scanf("%d%d",&numNode,&numEdge)==2,numNode || numEdge)
{
inputItial();
while(scanf("%d%d",&start,&End)==2,start!=-1 && End!=-1)
{
SPFA(start, End);
}
}
loadConstraints();
findShortestPath(group);
simulatedAnnealingForFindShortestPath(constraints, group);
#endif
srand(time(NULL));
//if(argc == 1)
// cout << "Not enough argument!" << endl;
LoadDataFromFile("C:\\Users\\Administrator\\Desktop\\case4.txt");
simulatedAnnealingForFindShortestPath(constraints, group);
//findInitialSolutionForSimulatedAnnealing(constraints, group);
//greedyAlgorithmForFindingInitialSolution(constraints, group);
SaveDataToFile("C:\\Users\\Administrator\\Desktop\\result0.txt", path);
system("pause");
return 0;
}
实验：
官网样例（18节点）：必经点：2 必经边：2
运行结果：
样例1（100节点）：必经点：10 必经边：5
运行结果：
样例2（300节点）：必经点：30 必经边：15
运行结果：
样例3（1000节点）：必经点：100 必经边：50
运行结果：
注：以上用例是ShooterIT大神提供，初写博客，太水，大佬勿喷~
扫一扫
4198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
