算法分析与设计实验报告——旅行售货商问题

算法分析与设计实验报告——旅行售货商问题

一、 实验目的

掌握分支限界法的基本思想和解决问题的基本步骤，认识回溯法和分支限界法的联系与区别。

二、实验要求

用c++语言实现分支限界法解决决旅行售货商问题，分析时间复杂性，体会分支限界法、回溯法解决问题的基本思路和步骤与区别。

三、 实验原理

四、 实验过程(步骤)

见附件一
实验步骤、特点
重要源代码（流操作的部分要醒目的提示并注释）

五、 运行结果

见附件二

六、实验分析与讨论

遇到的问题，及解决方案

七、实验特色与心得

附件一 实验过程(步骤)

#include "bits/stdc++.h"
const int INF = 100000;
const int MAX_N = 22;
using namespace std;
//n*n的一个矩阵
int n;
int cost[MAX_N][MAX_N];//最少3个点，最多MAX_N个点
struct Node
{
    bool visited[MAX_N];//标记哪些点走了
    int s;//第一个点
    int s_p;//第一个点的邻接点
    int e;//最后一个点
    int e_p;//最后一个点的邻接点
    int k;//走过的点数
    int sumv;//经过路径的距离
    int lb;//目标函数的值（目标结果）
    bool operator <(const Node &p)const
    {
        return p.lb < lb;//目标函数值小的先出队列
    }
};
priority_queue<Node> pq;//创建一个优先队列
int low, up;//下界和上界
bool dfs_visited[MAX_N];//在dfs过程中搜索过

//确定上界,利用dfs（属于贪心算法），贪心法的结果是一个大于实际值的估测结果
int dfs(int u, int k, int l)//当前节点，目标节点，已经消耗的路径
{
    if (k == n) return l + cost[u][1];//如果已经检查了n个节点，则直接返回路径消耗+第n个节点回归起点的消耗
    int minlen = INF, p;
    for (int i = 1; i <= n; i++)
    {
        if (!dfs_visited[i] && minlen > cost[u][i])//取与所有点的连边中最小的边
        {
            minlen = cost[u][i];//找出对于每一个节点，其可达节点中最近的节点
            p = i;
        }
    }
    dfs_visited[p] = true;//以p为下一个节点继续搜索
    return dfs(p, k + 1, l + minlen);
}
void get_up()
{
    dfs_visited[1] = true;//以第一个点作为起点
    up = dfs(1, 1, 0);
}
//用这种简单粗暴的方法获取必定小于结果的一个值
void get_low()
{
    //取每行最小值之和作为下界
    low = 0;
    for (int i = 1; i <= n; i++)
    {
        //创建一个等同于map的临时数组，可用memcpy
        int tmpA[MAX_N];
        for (int j = 1; j <= n; j++)
        {
            tmpA[j] = cost[i][j];
        }
        sort(tmpA + 1, tmpA + 1 + n);//对临时的数组进行排序
        low += tmpA[1];
    }
}
int get_lb(Node p)
{
    int ret = p.sumv * 2;//路径上的点的距离的二倍
    int min1 = INF, min2 = INF;//起点和终点连出来的边
    for (int i = 1; i <= n; i++)
    {
        if (!p.visited[i] && min1 > cost[i][p.s])
        {
            min1 = cost[i][p.s];
        }
    }
    ret += min1;
    for (int i = 1; i <= n; i++)
    {
        if (!p.visited[i] && min2 > cost[p.e][i])
        {
            min2 = cost[p.e][i];
        }
    }
    ret += min2;
    for (int i = 1; i <= n; i++)
    {
        if (!p.visited[i])
        {
            min1 = min2 = INF;
            for (int j = 1; j <= n; j++)
            {
                if (min1 > cost[i][j])
                    min1 = cost[i][j];
            }
            for (int j = 1; j <= n; j++)
            {
                if (min2 > cost[j][i])
                    min2 = cost[j][i];
            }
            ret += min1 + min2;
        }
    }
    return (ret + 1) / 2;
}

int solve()
{
    //贪心法确定上界
    get_up();
    //取每行最小的边之和作为下界
    get_low();
    //设置初始点,默认从1开始
    Node star;
    star.s = 1;//起点为1
    star.e = 1;//终点为1
    star.k = 1;//走过了1个点
    for (int i = 1; i <= n; i++)
    {
        star.visited[i] = false;
    }
    star.visited[1] = true;
    star.sumv = 0;//经过的路径距离初始化
    star.lb = low;//让目标值先等于下界    
    int ret = INF;//ret为问题的解
    pq.push(star);//将起点加入队列
    while (pq.size())
    {

        Node tmp = pq.top();pq.pop();
        if (tmp.k == n - 1)//如果已经走过了n-1个点
        {
            //找最后一个没有走的点
            int p;
            for (int i = 1; i <= n; i++)
            {
                if (!tmp.visited[i])
                {
                    p = i;//让没有走的那个点为最后点能走的点
                    break;
                }
            }
            int ans = tmp.sumv + cost[p][tmp.s] + cost[tmp.e][p];//已消耗+回到开始消耗+走到P的消耗
            //如果当前的路径和比所有的目标函数值都小则跳出
            if (ans <= tmp.lb)
            {
                ret = min(ans, ret);
                break;
            }
                //否则继续求其他可能的路径和，并更新上界
            else
            {
                up = min(up, ans);//上界更新为更接近目标的ans值
                ret = min(ret, ans);
                continue;
            }
        }
        //当前点可以向下扩展的点入优先级队列
        Node next;
        for (int i = 1; i <= n; i++)
        {
            if (!tmp.visited[i])
            {
                next.s = tmp.s;//沿着tmp走到next，起点不变
                next.sumv = tmp.sumv + cost[tmp.e][i];//更新路径和                
                next.e = i;//更新最后一个点                
                next.k = tmp.k + 1;//更新走过的顶点数                
                for (int j = 1; j <= n; j++) next.visited[j] = tmp.visited[j];//tmp经过的点也是next经过的点
                next.visited[i] = true;//自然也要更新当前点
                next.lb = get_lb(next);//求目标函数
                if (next.lb > up) continue;//如果大于上界就不加入队列
                pq.push(next);//否则加入队列
            }
        }
    }
    return ret;
}
int main()
{
    cout<<"请输入城市数量n：";
    cin >> n;
    cout<<"请输入距离矩阵："<<endl;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cin >> cost[i][j];
            if (i == j)
            {
                cost[i][j] = INF;
            }
        }
    }
    cout<<"最小距离为：";
    cout << solve() << endl;
    return 0;
}

/*
5
100000 5 61 34 12
57 100000 43 20 7
39 42 100000 8 21
6 50 42 100000 8
41 26 10 35 100000
*/

附件二 运行结果