uva 216 - Getting in Line 简单回溯 和 暴力求解

题目：

Computer networking requires that the computers in the network be linked.

This problem considers a ``linear" network in which the computers are chained together so that each is connected to exactly two others except for the two computers on the ends of the chain which are connected to only one other computer. A picture is shown below. Here the computers are the black dots and their locations in the network are identified by planar coordinates (relative to a coordinate system not shown in the picture).

Distances between linked computers in the network are shown in feet.

For various reasons it is desirable to minimize the length of cable used.

Your problem is to determine how the computers should be connected into such a chain to minimize the total amount of cable needed. In the installation being constructed, the cabling will run beneath the floor, so the amount of cable used to join 2 adjacent computers on the network will be equal to the distance between the computers plus 16 additional feet of cable to connect from the floor to the computers and provide some slack for ease of installation.

The picture below shows the optimal way of connecting the computers shown above, and the total length of cable required for this configuration is (4+16)+ (5+16) + (5.83+16) + (11.18+16) = 90.01 feet.

样例输入：

6
5 19
55 28
38 101
28 62
111 84
43 116
5
11 27
84 99
142 81
88 30
95 38
3
132 73
49 86
72 111
0

样例输出：

**********************************************************
Network #1
Cable requirement to connect (5,19) to (55,28) is 66.80 feet.
Cable requirement to connect (55,28) to (28,62) is 59.42 feet.
Cable requirement to connect (28,62) to (38,101) is 56.26 feet.
Cable requirement to connect (38,101) to (43,116) is 31.81 feet.
Cable requirement to connect (43,116) to (111,84) is 91.15 feet.
Number of feet of cable required is 305.45.
**********************************************************
Network #2
Cable requirement to connect (11,27) to (88,30) is 93.06 feet.
Cable requirement to connect (88,30) to (95,38) is 26.63 feet.
Cable requirement to connect (95,38) to (84,99) is 77.98 feet.
Cable requirement to connect (84,99) to (142,81) is 76.73 feet.
Number of feet of cable required is 274.40.
**********************************************************
Network #3
Cable requirement to connect (132,73) to (72,111) is 87.02 feet.
Cable requirement to connect (72,111) to (49,86) is 49.97 feet.
Number of feet of cable required is 136.99.

题目大意： 计算机网络需要网络中的电脑都相连。这是一个有关“线性网络”的问题。所有电脑被连成一条线。 两台电脑之间由一条缆线连接， 缆线的长度除了这两点间的直线长度，还要额外加上16米长。 因为连接的顺序方案不同，会产生不同的花费。 

题目要求我们求出花费最小的连接方案
一、暴力求解的思路很简单，把所有可能的连接方式算上一遍，然后在其中找到总长度最小的连接方式即可
n个点的不同的连接方式，可以用n的  全排列 来表示。

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

struct point
{
    int x;
    int y;
};
point p[10];
int a[10];
int b[10];
double ans[10];
double t_ans[10];

int main()
{
    int n;
    int k=0;
    while(scanf("%d",&n)!=EOF&&n)
    {
        memset(b,0,n);
        k++;
        for(int i=0; i<n; i++)
            scanf("%d%d",&p[i].x,&p[i].y);
        for(int i=0; i<n; i++)
            a[i]=i;
        double min=2147483647;
        do
        {
            double sum=0;
            for(int i=0; i<n-1; i++)
            {
                double temp1,temp2;
                temp1=p[a[i]].x-p[a[i+1]].x;
                temp2=p[a[i]].y-p[a[i+1]].y;
                t_ans[i]=hypot(temp1,temp2);
                sum+=t_ans[i]+16;
            }
            if(sum<min)
            {
                min=sum;
                memcpy(b,a,n*sizeof(int));
                memcpy(ans,t_ans,(n-1)*sizeof(double));
            }
        }
        while(next_permutation(a,a+n));
        printf("**********************************************************\n");
        printf("Network #%d\n",k);
        for(int i=0;i<n-1;i++)
            printf("Cable requirement to connect (%d,%d) to (%d,%d) is %.2lf feet.\n",p[b[i]].x,p[b[i]].y,p[b[i+1]].x,p[b[i+1]].y,ans[i]+16);
        printf("Number of feet of cable required is %.2lf.\n",min);
    }
    return 0;
}

用到了排列生成算法，next_permutation();
二、回溯法： 回溯法，也可以称之为递归枚举法，其与dfs深搜的不同在于，深搜是访问解答树的所有位置，而回溯是把问题分成若干步骤递归求解，会在访问时加以判断，如果当前步骤不会有合法选择的话，就不会再递归下去，而是返回上一层，这样就可以节省许多时间，不必要去访问那些没有意义的分支。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>

struct point
{
    int x;
    int y;
};
point p[10];

int n;
int ans[10];
double ans_sum[10];
double b[10];
int a[10];
int vis[10];
double min_sum;

void dfs(int cur,double sum)
{
    if(cur==n)
    {
        if(sum<min_sum)
        {
            min_sum=sum;
            memcpy(ans,a,sizeof(a));
            memcpy(ans_sum,b,sizeof(b));
        }
        return;
    }

    if(sum>min_sum) return;//这里是回溯思想的体现

    for(int i=0;i<n;++i)
    {
        if(vis[i]) continue;
        vis[i]=1;
        a[cur]=i;
        if(cur==0)
            dfs(cur+1,0);
        else
        {
            double temp1=p[i].x-p[a[cur-1]].x;
            double temp2=p[i].y-p[a[cur-1]].y;
            double t=hypot(temp1,temp2);
            b[cur-1]=t;
            dfs(cur+1,sum+t+16);
        }
        vis[i]=0;//回溯的关键步骤，回溯后清除上次的状态~
    }
}

int main()
{
        int case_=1;
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&p[i].x,&p[i].y);
        }
        memset(vis,0,sizeof(vis));
        memset(a,0,sizeof(a));
        min_sum=2147483647;

        dfs(0,0);

        printf("**********************************************************\n");
        printf("Network #%d\n",case_++);
        for(int i=0;i<n-1;i++)
        {
            printf("Cable requirement to connect (%d,%d) to (%d,%d) is %.2lf feet.\n",p[ans[i]].x,p[ans[i]].y,p[ans[i+1]].x,p[ans[i+1]].y,ans_sum[i]+16);
        }
        printf("Number of feet of cable required is %.2lf.\n",min_sum);
    }
    return 0;
}