算法训练 Car的旅行路线

问题描述
　　又到暑假了，住在城市A的Car想和朋友一起去城市B旅游。她知道每个城市都有四个飞机场，分别位于一个矩形的四个顶点上，同一个城市中两个机场之间有一 条笔直的高速铁路，第I个城市中高速铁路了的单位里程价格为Ti，任意两个不同城市的机场之间均有航线，所有航线单位里程的价格均为t。
　　那么Car应如何安排到城市B的路线才能尽可能的节省花费呢?她发现这并不是一个简单的问题，于是她来向你请教。
　　找出一条从城市A到B的旅游路线，出发和到达城市中的机场可以任意选取，要求总的花费最少。
输入格式
　　的第一行有四个正整数s，t，A，B。
　　S表示城市的个数，t表示飞机单位里程的价格，A，B分别为城市A，B的序号，(1<=A，B<=S)。
　　接下来有S行，其中第I行均有7个正整数xi1，yi1，xi2，yi2，xi3，yi3，Ti，这当中的(xi1，yi1)，(xi2，yi2)，(xi3，yi3)分别是第I个城市中任意三个机场的坐标，T I为第I个城市高速铁路单位里程的价格。
输出格式
　　共有n行，每行一个数据对应测试数据，保留一位小数。
样例输入
1
1 10 1 3
1 1 1 3 3 1 30
2 5 7 4 5 2 1
8 6 8 8 11 6 3
样例输出
47.55
数据规模和约定
　　0<S<=100，

思路：
只有三个点，运用几何平行关系求出第四个点，用对角点x和y都不相同的思路求出对角点，即三个点中必然有一个点和两个点要么x相同，要么y相同，这个点就是对角点。
如果x1和x4是对角关系,那么x1+x4=x2+x3,y1+y4=y2+y3(平行关系)
建立数组，把所有点之间的权值保存，w[i][j]表示i到j的权值，把起始城市的四个点分别当做起点，就变成单源最短路径算法，使用dijstra算法求出最短路径，最后比较4个起点最小路径值。

#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;
const double inf = 99999999;
struct node {
    int x, y, i;
};
vector<node >cp(1);
int s, t, a, b;
double w[500][500];

double d(int x1, int y1, int x2, int y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
 
}
bool p(int x1, int y1, int x2, int y2, int x3, int y3) 
{
    if ((x1 - x2) * (x1 - x3) + (y1 - y2) * (y1 - y3) == 0) 
    {
        return true;
    }
    else {
        return false;
    }
}
double dij(int start) //Dijkstra迪杰斯特拉算法，不断迭代求每个点距起点的最短距离，存入dij数组
{
    double dij[500];
    int book[500] = { 0 };
    fill(dij, dij + 500, inf);
    dij[start] = 0;
    for (int i = 1; i <= s * 4; i++) //遍历所有的点
    {
        double minn = inf;//哨兵
        int x = -1;
        for (int j = 1; j <= s * 4; j++) //每次找出距离起点最小的点，x，第一次找到start起点
        {
            if (book[j] == 0 && dij[j] < minn) //已找过的点不计 
            {
                minn = dij[j];
                x = j;
            }
        }
        if (x == -1) break;
        book[x] = 1;
        for (int j = 1; j <= s * 4; j++)//更新最短路径 
        {
            if (w[x][j] < inf && dij[j] > dij[x] + w[x][j]) {
                dij[j] = w[x][j] + dij[x];
            }
        }

    }
    double ans = inf;
    for (int i = 1; i <= 4; i++) {
        ans = min(ans, dij[(b - 1) * 4 + i]);
    }
    return ans;
}
int main() { 
    cin >> s >> t >> a >> b;
    int x1, y1, x2, y2, x3, y3, x4 = 0, y4 = 0, t_;
    fill(w[0], w[0] + 500 * 500, inf);
    
    for (int i = 1; i <= s; i++)
    {

        cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> t_;
        if (p(x1, y1, x2, y2, x3, y3)) //利用平行关系找第四个点
        {
            x4 = x2 - x1 + x3;//平行，x4+x1=x2+x3
            y4 = y2 - y1 + y3;
        }
        if (p(x2, y2, x1, y1, x3, y3)) {
            x4 = x1 - x2 + x3;
            y4 = y1 - y2 + y3;
        }
        if (p(x3, y3, x1, y1, x2, y2)) {
            x4 = x1 - x3 + x2;
            y4 = y1 - y3 + y2;
        }
        //一个城市各点间的权值
        w[(i - 1) * 4 + 1][(i - 1) * 4 + 2] = w[(i - 1) * 4 + 2][(i - 1) * 4 + 1] = d(x1, y1, x2, y2) * t_;
        w[(i - 1) * 4 + 1][(i - 1) * 4 + 3] = w[(i - 1) * 4 + 3][(i - 1) * 4 + 1] = d(x1, y1, x3, y3) * t_;
        w[(i - 1) * 4 + 1][(i - 1) * 4 + 4] = w[(i - 1) * 4 + 4][(i - 1) * 4 + 1] = d(x1, y1, x4, y4) * t_;
        w[(i - 1) * 4 + 2][(i - 1) * 4 + 3] = w[(i - 1) * 4 + 3][(i - 1) * 4 + 2] = d(x2, y2, x3, y3) * t_;
        w[(i - 1) * 4 + 2][(i - 1) * 4 + 4] = w[(i - 1) * 4 + 4][(i - 1) * 4 + 2] = d(x2, y2, x4, y4) * t_;
        w[(i - 1) * 4 + 3][(i - 1) * 4 + 4] = w[(i - 1) * 4 + 4][(i - 1) * 4 + 3] = d(x3, x3, x4, y4) * t_;
        cp.push_back({ x1, y1, i });//从cp[1]开始
        cp.push_back({ x2, y2, i });
        cp.push_back({ x3, y3, i });
        cp.push_back({ x4, y4, i });
    }
    for (int i = 1; i <= 4 * s; i++) 
    {
        for (int j = i + 1; j <= 4 * s; j++)//不同城市的点间的权值，*t
        {
            if (cp[i].i != cp[j].i) {
                w[i][j] = w[j][i] = d(cp[i].x, cp[i].y, cp[j].x, cp[j].y) * t;
            }
        }
    }
    
    double ans = inf;
    for (int i = 1; i <= 4; i++) //a城市为起点，把四个点分别作为起点，最后比较最小值
    {
        ans = min(ans, dij((a - 1) * 4 + i));
    }
    printf("%.2f", ans);
    return 0;
}