团体程序设计天梯赛练习集 PAT-L3 题解与程序（1~18题）

题目集链接：https://www.patest.cn/contests/gplt

2018年的天梯赛，鄙人很不幸成为了我们队的拖油瓶（手动笑哭

2018年的真题（19~21题）以后会更新……吧……

天梯赛的一点个人经（jiao）验（xun）：

该比赛没有罚时，而且测试点分值的分布极其诡异（经常是第一个小数据就十多分），所以尽最大可能骗分！

今年L3的三道题，3-1是一道极其恶心的模拟（手动AStyle），我x他xx的xxx这xx是什么xx玩意儿……

3-2和3-3都可以直接写暴力骗分。3-2我写了个O(n^4)的模拟骗了22分，3-3本可以骗些分的，结果我沙茶了没写……

前面的部分1-1和2-4都挺坑的。2-4要考虑-0的情形，恶心程度瞬间提升了几个档次（

个人感觉这套题的特点：思路不算很难，但是有些细节繁杂得要死。尤其是某些图论题（感觉基本上都是最短路）的输入和输出，不多说了自行体会。

考察的知识点不算多，不过比较考验实现能力，所以拿来练练手还是不错的。

贴一下本文部分代码用的板子。像#define pb(v, x) v.push_back(x)这样激进的缩写法我是完全习惯不了（手动笑哭）

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

#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <stdexcept>
#include <string>
#include <tuple>
#include <utility>

#define FILL(arr, ch) memset(arr, ch, sizeof(arr))

using namespace std;

using LL = long long;
template <class Tp>
using MinHeap = priority_queue<Tp, vector<Tp>, greater<Tp>>;
template <class Tp>
using MaxHeap = priority_queue<Tp>;

template <class RAIter>
inline void sortGt(RAIter first, RAIter last) { sort(first, last, greater<decltype(*first)>() ); }

const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;

inline bool isEq(double x, double y) { return fabs(x - y) <= eps; }
inline bool isLt(double x, double y) { return y - x > eps; }
inline bool isGt(double x, double y) { return x - y > eps; }

L3-001 凑零钱：01背包，输出方案

重点在于如何输出字典序最小的解。我们可以将所有硬币按面值从大到小排序，然后递推求dp数组。这样在倒推方案时，面值小的硬币尽可能先输出。

代码如下：（模板部分不再贴出，下同）

const int maxN = 1e4 + 5;
const int maxM = 100 + 5;

bool dp[maxN][maxM];
int val[maxN];
int N, M;

void input()
{
    scanf("%d%d", &N, &M);
    for (int i = 1; i <= N; i++)
        scanf("%d", val + i);
}

void printAns()
{
    if (!dp[N][M])
    {
        puts("No Solution");
        return;
    }
    auto printVal = [] (int x) -> void {
        static bool first = true;
        if (!first)
            putchar(' ');
        else
            first = false;
        printf("%d", x);
    };
    for (int n = N, m = M; n > 0 && m > 0; n--)
    {
        if (dp[n][m] && dp[n - 1][m - val[n]])
        {
            printVal(val[n]);
            m -= val[n];
        }
    }
}

void solve()
{
    sortGt(val + 1, val + N + 1);
    dp[0][0] = true;
    for (int i = 1; i <= N; i++)
    {
        for (int j = 0; j < val[i]; j++)
            dp[i][j] = dp[i - 1][j];
        for (int j = val[i]; j <= M; j++)
            dp[i][j] = dp[i - 1][j] | dp[i - 1][j - val[i]];
    }
    printAns();
}

int main()
{
    input();
    solve();
    return 0;
}

L3-002 堆栈：二分，树状数组

每当Push x时，给树状数组中第x位加上1；反之每当Pop时，设出栈的值为x，给树状数组中第x位减去1。

执行PeekMedian时，设当前栈中有n个元素，则所求的值x就是：满足树状数组中前x项前缀和>=(n+1)/2的最小值。

代码如下：

const int maxN = 1e5 + 10;

stack<int> stk;
int bit[maxN];
int N;

inline int lowbit(int x) { return x & -x; }

void addToBit(int val, int pos)
{
    for (; pos < maxN; pos += lowbit(pos))
        bit[pos] += val;
}

int getPrefix(int pos)
{
    int ans = 0;
    for (; pos; pos -= lowbit(pos))
        ans += bit[pos];
    return ans;
}

void printMedian()
{
    if (stk.empty())
    {
        puts("Invalid");
        return;
    }
    int lessN = (stk.size() - 1) >> 1;
    int left = 1, right = maxN - 1;
    while (left < right)
    {
        int mid = (left + right) >> 1;
        if (getPrefix(mid) <= lessN)
            left = mid + 1;
        else
            right = mid;
    }
    printf("%d
", left);
}

void pushToStack(int val)
{
    stk.push(val);
    addToBit(1, val);
}

void popFromStack()
{
    if (stk.empty())
    {
        puts("Invalid");
        return;
    }
    addToBit(-1, stk.top());
    printf("%d
", stk.top());
    stk.pop();
}

int main()
{
    scanf("%d", &N);
    char cmd[16];
    int x;
    while (N--)
    {
        scanf("%s", cmd);
        if (cmd[1] == 'u') //Push
        {
            scanf("%d", &x);
            pushToStack(x);
        }
        else if (cmd[1] == 'o') //pop
        {
            popFromStack();
        }
        else
        {
            printMedian();
        }
    }
    return 0;
}

L3-003 社交集群：并查集

不要求集群中任意两人都有共同爱好，所以直接并查集维护即可。另外不要把人的编号和兴趣的编号搞混。

代码如下：

const int maxN = 1000 + 5;

int N;
int last[maxN];
int ufs[maxN];

void init()
{
    FILL(last, -1);
    for (int i = 1; i <= N; i++)
        ufs[i] = i;
}

int findUfs(int x) { return ufs[x] == x ? x : (ufs[x] = findUfs(ufs[x])); }
void unifyUfs(int x, int y) { ufs[findUfs(x)] = findUfs(y); }

int main()
{
    scanf("%d", &N);
    init();
    for (int i = 1; i <= N; i++)
    {
        int n, id;
        scanf("%d:", &n);
        while (n--)
        {
            scanf("%d", &id);
            if (last[id] != -1)
                unifyUfs(i, last[id]);
            last[id] = i;
        }
    }
    vector<int> ans;
    for (int i = 1; i <= N; i++)
    {
        if (findUfs(i) != i)
            continue;
        int cnt = 0;
        for (int j = 1; j <= N; j++)
            if (findUfs(j) == i)
                cnt += 1;
        ans.push_back(cnt);
    }
    sortGt(ans.begin(), ans.end());
    printf("%zu
", ans.size());
    for (size_t i = 0; i < ans.size(); i++)
    {
        if (i != 0)
            putchar(' ');
        printf("%d", ans[i]);
    }
    return 0;
}

L3-004 肿瘤诊断：BFS

BFS判断联通块个数即可。

代码如下：

const int maxR = 1290;
const int maxC = 130;
const int maxL = 60;

bool cover[maxR][maxC][maxL];
bool vis[maxR][maxC][maxL];
int R, C, L, T;

void input()
{
    scanf("%d%d%d%d", &R, &C, &L, &T);
    int x;
    for (int k = 0; k < L; k++)
        for (int i = 0; i < R; i++)
            for (int j = 0; j < C; j++)
            {
                scanf("%d", &x);
                cover[i][j][k] = x;
            }
}

inline bool isValid(int r, int c, int l)
{
    return r >= 0 && r < R && c >= 0 && c < C && l >= 0 && l < L;
}
//up, down, left, right, front, back
const int dr[6] = {0, 0, 0, 0, 1, -1};
const int dc[6] = {0, 0, -1, 1, 0, 0};
const int dl[6] = {-1, 1, 0, 0, 0, 0};

int bfs(int r, int c, int l)
{
    using Tuple = tuple<int, int, int>;
    queue<Tuple> que;
    vis[r][c][l] = true;
    que.emplace(r, c, l);

    int res = 1;
    while (!que.empty())
    {
        tie(r, c, l) = que.front();
        que.pop();
        for (int i = 0; i < 6; i++)
        {
            int nr = r + dr[i], nc = c + dc[i], nl = l + dl[i];
            if (isValid(nr, nc, nl) && !vis[nr][nc][nl] && cover[nr][nc][nl])
            {
                vis[nr][nc][nl] = true;
                que.emplace(nr, nc, nl);
                res += 1;
            }
        }
    }
    return res;
}

int solve()
{
    int ans = 0;
    for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            for (int k = 0; k < L; k++)
                if (!vis[i][j][k] && cover[i][j][k])
                {
                    int temp = bfs(i, j, k);
                    if (temp >= T)
                        ans += temp;
                }
    return ans;
}

int main()
{
    input();
    printf("%d
", solve());
    return 0;
}

其中用来判断是否越界的isValid函数还可以进一步优化，优化后运行时间从165ms缩短为85ms，但由于编码量较大所以比赛中未必实用。

inline bool isValid(int i, int r, int c, int l)
{
    switch (i)
    {
        case 0: return l >= 0; break;
        case 1: return l < L; break;
        case 2: return c >= 0; break;
        case 3: return c < C; break;
        case 4: return r < R; break;
        case 5: return r >= 0; break;
    }
}

L3-005 垃圾箱分布：最短路

比较裸的最短路问题，不过要注意审题：

判断最优解的第一关键字：“垃圾箱的位置必须选在到所有居民点的最短距离最长的地方，居民点与垃圾箱之间不能超过D_S”；

第二关键字：“如果解不唯一，则输出到所有居民点的平均距离最短的那个解”；

第三关键字：“如果这样的解还是不唯一，则输出编号最小的地点”。

代码如下：

const int maxN = 1e3 + 15;
const int maxK = 1e4 + 15;
const int inf = 0x3f3f3f3f;

struct Edge
{
    int to, next, len;
    void assign(int t, int n, int l) { to = t; next = n; len = l; }
};

Edge elist[maxK * 2];
int head[maxN];
int ecnt;
int N, M, K, DS;

void initElist()
{
    FILL(head, -1);
    ecnt = 0;
}

inline void addEdge(int u, int v, int len)
{
    elist[ecnt].assign(v, head[u], len);
    head[u] = (ecnt++);
    elist[ecnt].assign(u, head[v], len);
    head[v] = (ecnt++);
}

inline int getId(const char* str) { return str[0] == 'G' ? N + atoi(str + 1) : atoi(str); }

void input()
{
    scanf("%d%d%d%d", &N, &M, &K, &DS);
    char s1[8], s2[8];
    int len;

    initElist();
    for (int i = 0; i < K; i++)
    {
        scanf("%s%s%d", s1, s2, &len);
        addEdge(getId(s1), getId(s2), len);
    }
}

int dist[maxN];
bool inq[maxN];
queue<int> que;

inline void pushToQue(int v)
{
    que.push(v);
    inq[v] = true;
}

inline int popFromQue()
{
    int v = que.front();
    que.pop();
    inq[v] = false;
    return v;
}

void spfa(int s)
{
    FILL(dist, 0x3f);
    dist[s] = 0;
    pushToQue(s);

    while (!que.empty())
    {
        int cur = popFromQue();
        for (int e = head[cur]; e != -1; e = elist[e].next)
        {
            int to = elist[e].to, len = elist[e].len;
            if (dist[cur] + len < dist[to])
            {
                dist[to] = dist[cur] + len;
                if (!inq[to])
                    pushToQue(to);
            }
        }
    }
}

void solve()
{
    int ansM = 0;
    double minAve = 1e20;
    int maxMinD = 0;

    for (int i = 1; i <= M; i++)
    {
        spfa(N + i);
        if (count(dist + 1, dist + N + 1, inf) || any_of(dist + 1, dist + N + 1, [] (int d) -> bool { return d > DS; }) )
            continue;
            
        double curAve = accumulate(dist + 1, dist + N + 1, 0.0) / N;
        int curMinD = *min_element(dist + 1, dist + N + 1);
        if (curMinD > maxMinD || (curMinD == maxMinD && curAve < minAve))
        {
            ansM = i;
            minAve = curAve;
            maxMinD = curMinD;
        }
    }

    if (ansM == 0)
        puts("No Solution");
    else
        printf("G%d
%.1f %.1f", ansM, (double)maxMinD, minAve);
}

int main()
{
    input();
    solve();
    return 0;
}

L3-006 迎风一刀斩：计算几何

“注意摆在你面前的两个多边形可不一定是端端正正摆好的，它们可能被平移、被旋转（逆时针90度、180度、或270度），或者被（镜像）翻面。”

由于旋转角一定是90°的倍数，因此可以得出：

结论1：如果一个多边形有两条及以上的斜边（横、纵坐标均不相等），那么它一定不是一刀切成的残片。

画图模拟一下，不难发现：

结论2：满足条件的残片一定不多于5条边；

结论3：如果两个残片可以拼成一个矩形，那么它们的边数之和不多于8。

结论4：满足条件的残片一定是凸多边形。

然后进一步分类讨论：

（1）如果两个残片都有3条边，检查这两个直角三角形是否全等即可。

（2）如果其中一个残片有3条边，另一个有4~5条，那么后者残缺的一块应该是一个与前一块残片全等的直角三角形。分析两块残片的斜边即可。

（3）如果两块残片都是矩形，检查它们是否有相等长度的边。

（4）如果两块残片都是有1条斜边的四边形，除了要检查两条斜边是否一致，还要检查两块残片内部的锐角是否相等，如下图。

代码如下（真·奇丑无比）：

#include <cstdio>
#include <algorithm>
#include <tuple>
#include <cmath>

using namespace std;
using LL = long long;

LL multi(int x1, int y1, int x2, int y2)
{
    return 1LL * x1 * y2 - 1LL * x2 * y1;
}

//isValid, isTriangle, N, longer, shorter, sinAngle
using Tuple = tuple<bool, bool, int, int, int, double>;

Tuple readFigure()
{
    int N;
    scanf("%d", &N);

    int fx, fy, lx, ly, cx, cy;
    int vecX, vecY;
    int skewCnt = 0;
    int longer, shorter;
    int posCnt = 0, negCnt = 0;
    double sinAngle = 0.0;
    bool valid = true;
    scanf("%d%d", &fx, &fy);
    lx = fx;
    ly = fy;

    auto updateSkew = [&] (int x1, int y1, int x2, int y2) -> void { //c1, l2
        skewCnt += 1;
        longer = abs(x1 - x2);
        shorter = abs(y1 - y2);
        if (longer <= shorter)
            swap(longer, shorter);

        LL multiRes = multi(-(y1 - y2), -(x1 - x2), vecX, vecY);
        if (posCnt > 0 && multiRes < 0 || negCnt > 0 && multiRes > 0)
            sinAngle = 1.0 * fabs(multiRes) / hypot(x1 - x2, y1 - y2) / hypot(vecX, vecY);
    };

    for (int i = 2; i <= N; i++)
    {
        scanf("%d%d", &cx, &cy);
        if (i > 2)
        {
            if (multi(vecX, vecY, cx - lx, cy - ly) < 0)
                negCnt += 1;
            else
                posCnt += 1;
        }
        if (cx != lx && cy != ly)
            updateSkew(cx, cy, lx, ly);
        vecX = cx - lx;
        vecY = cy - ly;
        if (i < N)
        {
            lx = cx;
            ly = cy;
        }
    }

    if (cx != fx && cy != fy)
        updateSkew(cx, cy, fx, fy);
    if (multi(vecX, vecY, fx - cx, fy - cy) < 0)
        negCnt += 1;
    else
        posCnt += 1;

    if (posCnt > 0 && negCnt > 0)
        valid = false;

    if (!valid || skewCnt >= 2)
        return make_tuple(false, false, 0, 0, 0, 0.0);
    if (skewCnt == 1)
        return make_tuple(true, true, N, longer, shorter, sinAngle);
    else
    {
        longer = abs(fx - cx + fy - cy);
        shorter = abs(cx - lx + cy - ly);
        if (longer <= shorter)
            swap(longer, shorter);
        return make_tuple(true, false, N, longer, shorter, sinAngle);
    }
}

bool solve()
{
    auto tp1 = readFigure();
    auto tp2 = readFigure();

    if (!get<0>(tp1) || !get<0>(tp2) || (get<1>(tp1) ^ get<1>(tp2)) || get<2>(tp1) + get<2>(tp2) >= 9)
        return false;
    if (get<1>(tp1))
    {
        bool res = get<3>(tp1) == get<3>(tp2) && get<4>(tp1) == get<4>(tp2);
        if (get<2>(tp1) == 4 && get<2>(tp2) == 4)
            res &= (fabs(get<5>(tp1) - get<5>(tp2)) < 1e-6);
        return res;
    }
    else
        return get<3>(tp1) == get<3>(tp2) || get<4>(tp1) == get<4>(tp2) ||
                                             get<3>(tp1) == get<4>(tp2) ||
                                             get<4>(tp1) == get<3>(tp2);
}

int main()
{
    int T;
    for (scanf("%d", &T); T; T--)
    {
        printf("%s
", solve() ? "YES" : "NO");
    }
    return 0;
}

L3-007 天梯地图：最短路，输出方案

依然是比较裸的最短路，但要比“垃圾箱分布”恶心得多。依然是注意审题：

判别最快到达路线的第二关键字：“如果最快到达路线不唯一，则输出几条最快路线中最短的那条，题目保证这条路线是唯一的”。

判别最短距离路线的第二关键字：“而如果最短距离的路线不唯一，则输出途径节点数最少的那条，题目保证这条路线是唯一的”。

为了避免代码重复，可以考虑将dist的递推式作为dijkstra函数的参数。C++11里借助Lambda表达式可以很方便地实现。

代码如下：

using Pair = pair<int, int>;

const int maxN = 500 + 5;
int gTime[maxN][maxN];
int gLen[maxN][maxN];
int N, M, S, T;

void input()
{
    scanf("%d%d", &N, &M);
    FILL(gTime, 0x3f);
    FILL(gLen, 0x3f);

    for (int u, v, o, l, t, i = 0; i < M; i++)
    {
        scanf("%d%d%d%d%d", &u, &v, &o, &l, &t);
        gTime[u][v] = t;
        gLen[u][v] = l;
        if (o == 0)
        {
            gTime[v][u] = t;
            gLen[v][u] = l;
        }
    }
    scanf("%d%d", &S, &T);
}

Pair dist[maxN];
int bef[maxN];
bool vis[maxN];

void initDijkstra()
{
    FILL(dist, 0x3f);
    FILL(vis, 0);
    dist[S] = Pair(0, 0);
}

pair<int, vector<int>> dijkstra(function<Pair(int, int)> procFn)
{
    initDijkstra();

    int cur = S;
    for (int _i = 1; _i < N; ++_i)
    {
        vis[cur] = true;
        for (int j = 0; j < N; j++)
            if (!vis[j] && procFn(cur, j) < dist[j])
            {
                dist[j] = procFn(cur, j);
                bef[j] = cur;
            }
        auto nextD = Pair(inf, inf);
        for (int j = 0; j < N; j++)
            if (!vis[j] && dist[j] < nextD)
            {
                nextD = dist[j];
                cur = j;
            }
    }

    vector<int> res;
    for (cur = T; ; cur = bef[cur])
    {
        res.push_back(cur);
        if (cur == S)
            break;
    }
    return { dist[T].first, move(res) };
}

void printPath(const vector<int> &vec)
{
    for (auto it = vec.crbegin(); it != vec.crend(); ++it)
    {
        if (it != vec.crbegin())
            printf(" => ");
        printf("%d", *it);
    }
    putchar('
');
}

void solve()
{
    auto resTime = dijkstra([] (int u, int v) {
        return Pair(dist[u].first + gTime[u][v], dist[u].second + gLen[u][v]);
    });
    auto resLen = dijkstra([] (int u, int v) {
        return Pair(dist[u].first + gLen[u][v], dist[u].second + 1);
    });

    if (resTime.second == resLen.second)
    {
        printf("Time = %d; Distance = %d: ", resTime.first, resLen.first);
        printPath(resTime.second);
    }
    else
    {
        printf("Time = %d: ", resTime.first);
        printPath(resTime.second);
        printf("Distance = %d: ", resLen.first);
        printPath(resLen.second);
    }
}

int main()
{
    input();
    solve();
    return 0;
}

 L3-008 喊山：BFS

直接BFS即可。代码如下：

struct Edge
{
    int to, next;
    void assign(int t, int n) { to = t; next = n; }
};

const int maxN = 1e4 + 5;
const int maxM = 1e6 + 5;

Edge elist[maxM];
int head[maxN];
int qry[12];
int ecnt = 0;
int N, M, K;

void initElist()
{
    FILL(head, -1);
    ecnt = 0;
}

inline void addEdge(int u, int v)
{
    elist[ecnt].assign(v, head[u]);
    head[u] = (ecnt++);
    elist[ecnt].assign(u, head[v]);
    head[v] = (ecnt++);
}

void input()
{
    scanf("%d%d%d", &N, &M, &K);
    initElist();
    for (int u, v, i = 0; i < M; i++)
    {
        scanf("%d%d", &u, &v);
        addEdge(u, v);
    }
    for (int i = 1; i <= K; i++)
        scanf("%d", qry + i);
}

int dist[maxN];

int bfs(int s)
{
    FILL(dist, -1);
    dist[s] = 0;

    queue<int> que;
    que.push(s);

    while (!que.empty())
    {
        int cur = que.front();
        que.pop();
        for (int e = head[cur]; e != -1; e = elist[e].next)
        {
            int to = elist[e].to;
            if (dist[to] == -1)
            {
                dist[to] = dist[cur] + 1;
                que.push(to);
            }
        }
    }

    auto pos = max_element(dist + 1, dist + N + 1);
    if (*pos <= 0)
        return 0;
    else
        return (int)(pos - dist);
}

void solve()
{
    for (int i = 1; i <= K; i++)
        printf("%d
", bfs(qry[i]));
}

int main()
{
    input();
    solve();
    return 0;
}

L3-009 长城：凸包

链接：http://www.cnblogs.com/Onlynagesha/p/8672128.html

L3-010 是否完全二叉树：BFS，模拟

按题目要求建树然后BFS。判断它是否为完全二叉树，就看是否存在唯一的节点S满足：

（1）S要么只有左孩子，要么没有孩子；

（2）BFS过程中，它之前的节点都有2个孩子；

（3）BFS过程中，它后边的节点都没有孩子。

代码如下：

struct Node
{
    int val;
    Node *lch, *rch;
    Node(int v): val(v), lch(nullptr), rch(nullptr) {}
};

Node* insert(int val, Node* cur)
{
    if (cur == nullptr)
        return new Node(val);
    if (val > cur->val)
        cur->lch = insert(val, cur->lch);
    else
        cur->rch = insert(val, cur->rch);
    return cur;
}

bool bfs(Node *root)
{
    bool res = true;
    bool fin = false;

    queue<Node*> que;
    que.push(root);

    while (!que.empty())
    {
        Node *cur = que.front();
        que.pop();
        if (cur != root)
            putchar(' ');
        printf("%d", cur->val);

        if (cur->lch)
            que.push(cur->lch);
        if (cur->rch)
            que.push(cur->rch);

        if (!cur->lch && cur->rch)
            res = false;
        else if (fin && (cur->lch || cur->rch))
            res = false;
        if (!cur->rch)
            fin = true;
    }

    putchar('
');
    return res;
}

int main()
{
    int N;
    Node *root = nullptr;

    scanf("%d", &N);
    for (int x, i = 1; i <= N; i++)
    {
        scanf("%d", &x);
        root = insert(x, root);
    }

    if (bfs(root))
        printf("YES");
    else
        printf("NO");

    return 0;
}

L3-011 直捣黄龙：最短路，输出方案

我的妈呀这么多最短路……还一个比一个恶心（后边有个更恶心的）……

照着题意做即可。注意输出部分的要求是“第二行顺序输出最快进攻路径的条数、最短进攻距离、歼敌总数”，这个统计方案数放在最后真的很容易忽略啊，害得我最后还得补代码￣へ￣

代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <tuple>
#include <map>
#include <string>
#include <stack>

#define FILL(arr, ch) memset(arr, ch, sizeof(arr))

const int maxN = 200 + 10;
const int inf = 0x3f3f3f3f;

using Tuple = std::tuple<int, int, int>;

std::map<std::string, int> idMap;
std::map<int, std::string> nameMap;
int enemyN[maxN];
int graph[maxN][maxN];
int N, K, S, T;

int getId(const std::string& str)
{
    auto iter = idMap.find(str);
    if (iter != idMap.end())
        return iter->second;
    idMap.emplace(str, (int)idMap.size() + 1);
    nameMap.emplace((int)idMap.size(), str);
    return (int)idMap.size();
}

inline const std::string& getName(int id)
{
    return nameMap.find(id)->second;
}

void input()
{
    std::string s1, s2;
    std::cin >> N >> K >> s1 >> s2;
    S = getId(s1);
    T = getId(s2);

    for (int i = 1; i < N; i++)
    {
        std::cin >> s1;
        int id = getId(s1);
        std::cin >> enemyN[id];
    }
    FILL(graph, 0x3f);
    int len;
    for (int i = 1; i <= K; i++)
    {
        std::cin >> s1 >> s2 >> len;
        int id1 = getId(s1);
        int id2 = getId(s2);
        graph[id1][id2] = graph[id2][id1] = len;
    }
}

struct Dist
{
    int len;
    int nodeN;
    int totEnemyN;

    bool operator < (const Dist& rhs) const
    {
        if (len != rhs.len)
            return len < rhs.len;
        if (nodeN != rhs.nodeN)
            return nodeN > rhs.nodeN;
        return totEnemyN > rhs.totEnemyN;
    }

    Dist advance(int u, int v) const {
        return { len + graph[u][v], nodeN + 1, totEnemyN + enemyN[v] };
    }
};

Dist dist[maxN];
bool vis[maxN];
int prev[maxN];
int cnt[maxN];

void initDijkstra()
{
    FILL(dist, 0x3f);
    dist[S] = { 0, 1, 0 };
    cnt[S] = 1;
}

void dijkstra()
{
    initDijkstra();
    int cur = S;
    for (int i = 1; i < N; i++)
    {
        vis[cur] = true;
        for (int j = 1; j <= N; j++)
        {
            auto nextDist = dist[cur].advance(cur, j);
            if (nextDist.len < dist[j].len)
                cnt[j] = cnt[cur];
            else if (nextDist.len == dist[j].len)
                cnt[j] += cnt[cur];

            if (!vis[j] && nextDist < dist[j])
            {
                dist[j] = nextDist;
                prev[j] = cur;
            }
        }

        Dist minDist { inf, inf, inf };
        for (int j = 1; j <= N; j++)
            if (!vis[j] && dist[j] < minDist)
            {
                minDist = dist[j];
                cur = j;
            }
    }
}

void solve()
{
    dijkstra();
    std::stack<int> path;

    for (int cur = T; ; cur = prev[cur])
    {
        path.push(cur);
        if (cur == S)
            break;
    }
    bool first = true;
    while (!path.empty())
    {
        int cur = path.top();
        path.pop();
        if (!first)
            std::cout << "->";
        first = false;
        std::cout << getName(cur);
    }
    std::cout << '
' << cnt[T] << ' ' << dist[T].len << ' ' << dist[T].totEnemyN;
}

int main()
{
    input();
    solve();
    return 0;
}

L3-012 水果忍者：计算几何，枚举

比较考验思路的一题。不过本题数据量比较小，N<=1e4的话可以用O(N^2)的算法挤进去，我加了一系列优化以后最后一个测试点只用了11ms。

题解：http://blog.csdn.net/foreyes_1001/article/details/52208749

代码如下：

#include <cctype>
#include <cmath>
#include <cstdio>
#include <stdexcept>
#include <algorithm>

using namespace std;

using LL = long long;

const int inf = 0x3f3f3f3f;

template <class IntType>
IntType gcd(IntType x, IntType y)
{
    return y ? gcd(y, x % y) : x;
}

struct Fraction
{
    int num, den; //numerator / denominator
    void assign(int _num, int _den = 1)
    {
        if (_den == 0)
            throw invalid_argument("Denominator should not be 0!");
        if (_den < 0)
        {
            _num = - _num;
            _den = - _den;
        }
        int g = gcd(abs(_num), _den);
        num = _num / g;
        den = _den / g;
    }
    bool operator < (const Fraction& rhs) const { return 1LL * num * rhs.den < 1LL * den * rhs.num; }
    bool operator == (const Fraction& rhs) const
    {
        if (num == 0)
            return rhs.num == 0;
        return num == rhs.num && den == rhs.den;
    }

    Fraction(): num(0), den(1) {}
    Fraction(int _num, int _den = 1) { assign(_num, _den); }
};

const int maxN = 10000 + 10;
struct Line
{
    int x, yUp, yDown, len;
    void assign(int x, int yu, int yd) { this->x = x; yUp = yu; yDown = yd; len = yUp - yDown; }
    bool operator < (const Line& rhs) const { return len < rhs.len; }
};
Line line[maxN];
int N;

inline Fraction scopeUp(int vUp, int vDown)
{
    return {line[vUp].yUp - line[vDown].yDown, line[vUp].x - line[vDown].x};
}
inline Fraction scopeDown(int v1, int v2)
{
    return {line[v1].yDown - line[v2].yDown, line[v1].x - line[v2].x};
}

void input()
{
    scanf("%d", &N);
    int x, yu, yd;
    for (int i = 1; i <= N; i++)
    {
        scanf("%d%d%d", &x, &yu, &yd);
        line[i].assign(x, yu, yd);
    }
}

void solve()
{
    sort(line + 1, line + N + 1);
    for (int ct = 1; ct <= N; ++ct)
    {
        Fraction minScope(-inf), maxScope(inf);
        bool ok = true;
        auto judgeSameX = [&ok, &ct] (int i) {
            bool res = (line[i].x == line[ct].x);
            if (res && (line[i].yUp < line[ct].yDown || line[i].yDown > line[ct].yDown))
                ok = false;
            return res;
        };
        auto judgeScope = [&] () {
            if (maxScope < minScope)
                ok = false;
        };
        for (int i = 1; ok && i <= N; i++)
            if (!judgeSameX(i))
            {
                if (line[i].x < line[ct].x)
                {
                    minScope = max(minScope, scopeUp(i, ct));
                    maxScope = min(maxScope, scopeDown(ct, i));
                }
                else
                {
                    minScope = max(minScope, scopeDown(i, ct));
                    maxScope = min(maxScope, scopeUp(i, ct));
                }
                judgeScope();
            }
        if (ok)
        {
            printf("%d %d %d %d", line[ct].x, line[ct].yDown,
                   line[ct].x + minScope.den, line[ct].yDown + minScope.num);
            return;
        }
    }
    throw logic_error("Answer not found!");
}

int main()
{
    input();
    solve();
    return 0;
}

L3-013 非常弹的球：数学，物理

根据物理公式推导即可，答案是一个无穷级数。注意单位的转换。

代码如下：

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
  int w, p;
  cin >> w >> p;
  cout << fixed << setprecision(3) << 2000.0 / (9.8 * w / 100.0 * p / 100.0);
  return 0;
}

L3-014 周游世界：最短路，输出方案

整套题集最恶心的最短路没有之一。

代码里用了拆点的思想，将不同线路交错的换乘点拆成多个。状态转移时以经停站数量为第一关键字，以换乘次数为第二关键字。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <utility>
#include <queue>
#include <stack>

#define FILL(arr, ch) memset(arr, ch, sizeof(arr))

const int inf = 0x3f3f3f3f;

struct OldNode
{
    std::vector<int> newNodes;
};
OldNode oldNodes[10000];

struct NewNode
{
    int spotId;
    int routeId;
    NewNode(int s, int r): spotId(s), routeId(r) {}
};
std::vector<NewNode> newNodes;

int createNewNode(int spotId, int routeId)
{
    auto newId = static_cast<int>(newNodes.size());
    newNodes.emplace_back(spotId, routeId);
    oldNodes[spotId].newNodes.push_back(newId);
    return newId;
}

struct Edge
{
    int to, next;
    void assign(int t, int n) { to = t; next = n; }
};
Edge elist[100005];
int head[10005];
int ecnt;
int routeN;

void initEList() { FILL(head, -1); ecnt = 0; }

inline void addEdge(int u, int v) //bidirectional
{
    elist[ecnt].assign(v, head[u]);
    head[u] = (ecnt++);
    elist[ecnt].assign(u, head[v]);
    head[v] = (ecnt++);
}

void inputGraph()
{
    scanf("%d", &routeN);
    initEList();
    for (int routeId = 1; routeId <= routeN; ++routeId)
    {
        int spotN, spotId;
        scanf("%d%d", &spotN, &spotId);
        int lastNewId = createNewNode(spotId, routeId);
        int curNewId;
        for (int i = 2; i <= spotN; i++)
        {
            scanf("%d", &spotId);
            curNewId = createNewNode(spotId, routeId);
            addEdge(lastNewId, curNewId);
            lastNewId = curNewId;
        }
    }
}

using Pair = std::pair<int, int>;

std::queue<int> que;
Pair dist[10005];
int prev[10005];
bool inq[10005];

void initSpfa(int startSpot)
{
    FILL(dist, 0x3f);
    for (auto newId: oldNodes[startSpot].newNodes)
    {
        dist[newId] = {0, 0};
        que.push(newId);
    }
}

inline void pushToQueue(int v)
{
    if (inq[v])
        return;
    inq[v] = true;
    que.push(v);
}

inline int popFromQueue()
{
    int v = que.front();
    que.pop();
    inq[v] = false;
    return v;
}

inline void updateDist(int from, int to, const Pair& nextDist)
{
    if (nextDist < dist[to])
    {
        dist[to] = nextDist;
        prev[to] = from;
        pushToQueue(to);
    }
}

void spfa(int startSpot)
{
    initSpfa(startSpot);
    while (!que.empty())
    {
        int cur = popFromQueue();

        int oldId = newNodes[cur].spotId;
        for (auto to: oldNodes[oldId].newNodes)
        {
            if (to == cur)
                continue;
            Pair nextDist { dist[cur].first, dist[cur].second + 1 };
            updateDist(cur, to, nextDist);
        }
        for (int e = head[cur]; e != -1; e = elist[e].next)
        {
            int to = elist[e].to;
            Pair nextDist { dist[cur].first + 1, dist[cur].second };
            updateDist(cur, to, nextDist);
        }
    }
}

void printPath(int startOldId, int endNewId)
{
    std::stack<int> stk;
    for (int cur = endNewId; ; cur = prev[cur])
    {
        stk.push(cur);
        if (newNodes[cur].spotId == startOldId)
            break;
    }
    auto popFromStack = [&stk] () {
        int v = stk.top();
        stk.pop();
        return v;
    };
    int head = popFromStack();
    int tail = popFromStack();
    auto printLine = [&head, &tail] () {
        printf("Go by the line of company #%d from %04d to %04d.
",
               newNodes[head].routeId, newNodes[head].spotId, newNodes[tail].spotId);
    };
    while (!stk.empty())
    {
        if (newNodes[stk.top()].routeId != newNodes[head].routeId)
        {
            printLine();
            head = popFromStack();
        }
        else
            tail = popFromStack();
    }
    printLine();
}

void solve(int startSpot, int endSpot)
{
    spfa(startSpot);
    Pair minDist {inf, inf};
    int endNewId = -1;
    for (int newId: oldNodes[endSpot].newNodes)
        if (dist[newId] < minDist)
        {
            minDist = dist[newId];
            endNewId = newId;
        }
    if (endNewId == -1)
        printf("Sorry, no line is available.
");
    else
    {
        printf("%d
", dist[endNewId].first);
        printPath(startSpot, endNewId);
    }
}

int main()
{
    inputGraph();
    int Q, s, t;
    scanf("%d", &Q);
    for (int i = 0; i < Q; i++)
    {
        scanf("%d%d", &s, &t);
        solve(s, t);
    }
    return 0;
}

L3-015 球队“食物链”：TSP，状态压缩DP

类比旅行商问题的DP解法：设dp[v][S]表示从节点v出发，遍历点集S中所有节点，然后回到节点1的字典序最小的路径（也可能不存在）。

伪代码形式的状态转移方程：

dp[v][S] = noPath
for each u in S:
    if dp[u][S - v] != noPath
        update dp[v][S]

存储中间路径时只需保存下一个节点是谁，不需要保留整条路径。

代码如下：（代码中节点编号是0 ~ N - 1，另外这份代码写得确实很丑，毕竟我太弱又好久没写过状压DP(；′⌒`）

const int maxN = 20;

int N;
bool graph[maxN][maxN];

void input()
{
    char str[maxN][maxN + 1];
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
        scanf("%s", str[i]);
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
        {
            if (str[i][j] == 'W')
                graph[i][j] = true;
            else if (str[i][j] == 'L')
                graph[j][i] = true;
        }
}

struct BSet
{
    int size;
    int val;
    void assign(int v)
    {
        val = v;
        size = 0;
        for (; v; v >>= 1)
            size += v & 1;
    }
    bool operator < (const BSet& rhs) const {
        return size < rhs.size || (size == rhs.size && val < rhs.val);
    }
    bool hasNode(int n) const {
        n -= 1;
        return (val >> n) & 1;
    }
    int remove(int n) const {
        n -= 1;
        return val & (-1 ^ (1 << n));
    }
};

BSet bset[1 << maxN];
int to[maxN][1 << maxN];

void initBSet()
{
    int lim = (1 << (N - 1));
    for (int i = 0; i < lim; i++)
        bset[i].assign(i);
    sort(bset, bset + lim);
}

void solve()
{
    FILL(to, -1);
    initBSet();
    for (int i = 1; i < N; i++)
        if (graph[i][0])
            to[i][0] = 0;

    int lim = (1 << (N - 1));
    for (int s = 1; s < lim; s++)
    {
        for (int i = 0; i < N; i++) //dp[i][bset[s].val]
        {
            if (i > 0 && bset[s].hasNode(i))
                continue;
            for (int j = 1; j < N; j++)
            {
                if (!bset[s].hasNode(j))
                    continue;
                if (graph[i][j] && to[j][bset[s].remove(j)] != -1)
                {
                    to[i][bset[s].val] = j;
                    break;
                }
            }
        }
    }

    if (to[0][lim - 1] == -1)
    {
        printf("No Solution");
        return;
    }
    int S = lim - 1;
    int cur = 0;
    for (int i = 0; i < N; i++)
    {
        if (i != 0)
            putchar(' ');
        printf("%d", cur + 1);
        cur = to[cur][S];
        S ^= (1 << (cur - 1));
    }
}

int main()
{
    input();
    solve();
    return 0;
}

L3-016 二叉搜索树的结构：模拟，字符串

按照题意模拟即可，就是多种询问处理起来有些麻烦。此外要注意询问的数值不在二叉树内的情况。

处理询问格式时我用了C++11的正则表达式库，这玩意儿编译起来真的好慢啊，第一次交居然编译超时……

注意捕获整数的格式应为-?d+（前面有0~1个负号）。代码里的写法是错误的，那样可能捕获多个负号，不过本题并不受影响。

还有用try - catch判断非法数值的方法可以说是粗陋至极了(￣▽￣)／

代码如下：

struct Node
{
    int val;
    size_t lch, rch, par;
    Node(int v, size_t p = -1): val(v), lch(-1), rch(-1), par(p) {}
};
vector<Node> node;
int N, M;

void insert(int x)
{
    if (node.empty())
    {
        node.emplace_back(x);
        return;
    }
    size_t cur = 0;
    size_t nextV = (x < node[0].val) ? node[0].lch : node[0].rch;
    while (nextV != -1)
    {
        cur = nextV;
        nextV = (x < node[cur].val) ? node[cur].lch : node[cur].rch;
    }

    *(x < node[cur].val ? &node[cur].lch : &node[cur].rch) = node.size();
    node.emplace_back(x, cur);
}

pair<size_t, int> _findNode(int val)
{
    size_t cur = 0;
    int layer = 0;
    while (cur != -1)
    {
        if (node[cur].val == val)
            return { cur, layer };
        layer += 1;
        if (val < node[cur].val)
            cur = node[cur].lch;
        else
            cur = node[cur].rch;
    }
    throw invalid_argument("val not found!");
}

inline size_t findNode(int val) { return _findNode(val).first; }
inline size_t getLayer(int val) { return _findNode(val).second; }

bool checkRoot(int a) { return node[0].val == a; }
bool checkSiblings(int a, int b) { return node[findNode(a)].par == node[findNode(b)].par; }
bool checkParent(int a, int b) { return node[findNode(b)].par == findNode(a); }
bool checkLeftChild(int a, int b) { return node[findNode(b)].lch == findNode(a); }
bool checkRightChild(int a, int b) { return node[findNode(b)].rch == findNode(a); }
bool checkSameLevel(int a, int b) { return getLayer(a) == getLayer(b); }

#define SOLVE_BRANCH(rgx, func) 
    if (regex_match(cmd, rgxResult, rgx)) { 
        try { return func(stoi(rgxResult[1].str()), stoi(rgxResult[2].str())); } 
        catch (invalid_argument) { return false; } 
    }

bool solve(const char* cmd)
{
    static regex rgxCheckRoot {R"((-*d+) is the root
*)"},
                 rgxCheckSiblings {R"((-*d+) and (-*d+) are siblings
*)"},
                 rgxCheckParent {R"((-*d+) is the parent of (-*d+)
*)"},
                 rgxCheckLeftChild {R"((-*d+) is the left child of (-*d+)
*)"},
                 rgxCheckRightChild {R"((-*d+) is the right child of (-*d+)
*)"},
                 rgxCheckSameLevel {R"((-*d+) and (-*d+) are on the same level
*)"};

    cmatch rgxResult;
    if (regex_match(cmd, rgxResult, rgxCheckRoot))
        return checkRoot(stoi(rgxResult[1].str()));

    SOLVE_BRANCH(rgxCheckSiblings, checkSiblings);
    SOLVE_BRANCH(rgxCheckParent, checkParent);
    SOLVE_BRANCH(rgxCheckLeftChild, checkLeftChild);
    SOLVE_BRANCH(rgxCheckRightChild, checkRightChild);
    SOLVE_BRANCH(rgxCheckSameLevel, checkSameLevel);

    throw invalid_argument("Error while matching command!");
}

int main()
{
    scanf("%d", &N);
    for (int x, i = 0; i < N; i++)
    {
        scanf("%d", &x);
        insert(x);
    }
    char cmd[1234];
    scanf("%d", &M);
    while (getchar() != '
');
    for (int i = 0; i < M; i++)
    {
        fgets(cmd, 1234, stdin);
        printf("%s
", solve(cmd) ? "Yes" : "No");
    }
    return 0;
}

L3-017 森森快递：贪心，线段树

如果区间A包含了区间B，那么选择区间A显然是没有意义的。选择A的收益不会比选择B高，且会导致更多资源的浪费。

然后考虑其他不被包含的区间，将它们按左端点从小到大排序（此时右端点也是排好序的），此时我们的贪心策略是：尽可能利用左边的区间，从而给右边创造更多机会。

因为涉及区间修改，以及查询区间内最小值这两种操作，所以需要借助线段树维护。

代码如下：（线段树写得比较丑(*/ω＼*）

const int maxN = 1e5 + 10;

struct Node
{
    int val;
    int tag;
    Node *lch, *rch;

    Node(int v, Node* l = nullptr, Node* r = nullptr):
            val(v), tag(0), lch(l), rch(r) {}

    void pushTag()
    {
        if (tag == 0)
            return;

        val += tag;
        if (lch)
        {
            lch->tag += this->tag;
            rch->tag += this->tag;
        }
        tag = 0;
    }
};

struct Range
{
    int left, right;
    Range(int l, int r): left(l), right(r) {}
    bool operator < (const Range& rhs) const {
        return right < rhs.right || (right == rhs.right && left > rhs.left);
    }
};

vector<Node> segTree;
vector<Range> range;
Node *root;
int lim[maxN];
int N, Q;

Node* _initSegTree(int left, int right)
{
    if (right - left == 1)
    {
        segTree.emplace_back(lim[left]);
        return &segTree.back();
    }
    int mid = (left + right) >> 1;
    auto pl = _initSegTree(left, mid), pr = _initSegTree(mid, right);
    segTree.emplace_back(min(pl->val, pr->val), pl, pr);
    return &segTree.back();
}

void initSegTree()
{
    segTree.reserve(N * 2 + 10);
    root = _initSegTree(1, N);
}

namespace _SegTree_Impl
{
    int rl, rr, delta;
}

void _modify(int nl, int nr, Node* cur)
{
    using namespace _SegTree_Impl;
    cur->pushTag();
    if (rl <= nl && rr >= nr)
    {
        cur->tag += delta;
        cur->pushTag();
        return;
    }
    else if (rl >= nr || rr <= nl)
        return;

    int mid = (nl + nr) >> 1;
    _modify(nl, mid, cur->lch);
    _modify(mid, nr, cur->rch);
    cur->val = min(cur->lch->val, cur->rch->val);
}

void modify(int left, int right, int v)
{
    using namespace _SegTree_Impl;
    if (v == 0)
        return;

    rl = left;
    rr = right;
    delta = v;
    _modify(1, N, root);
}

int _query(int nl, int nr, Node* cur)
{
    using namespace _SegTree_Impl;
    cur->pushTag();
    if (rl <= nl && rr >= nr)
        return cur->val;
    else if (rl >= nr || rr <= nl)
        return 0x7fffffff;

    int mid = (nl + nr) >> 1;
    return min(_query(nl, mid, cur->lch), _query(mid, nr, cur->rch));
}

int query(int left, int right)
{
    using namespace _SegTree_Impl;
    rl = left;
    rr = right;
    return _query(1, N, root);
}

void input()
{
    scanf("%d%d", &N, &Q);
    for (int i = 1; i < N; i++)
        scanf("%d", lim + i);
    for (int i = 1; i <= Q; i++)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        if (x > y)
            swap(x, y);
        range.emplace_back(x + 1, y + 1);
    }
}

void solve()
{
    initSegTree();
    sort(range.begin(), range.end());

    LL ans = 0;
    for (const auto& rng: range)
    {
        int left = rng.left;
        int right = rng.right;
        int qryRes = query(left, right);
        ans += qryRes;
        modify(left, right, -qryRes);
    }

    printf("%lld", ans);
}

int main()
{
    input();
    solve();
    return 0;
}

 L3-018 森森美图：最短路

在最短路的基础上稍微涉及了些计算几何的知识。

求start→end的最短路时，要求途径的节点都在向量start→end的逆时针方向（配合向量叉积判断），对于两个端点只计算end的权值。

求end→start的最短路时，要求途径的节点都在向量end→start的逆时针方向，对于两个端点只计算start的权值。

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <functional>

using namespace std;

const double sqrt2 = sqrt(2.0);
const int maxN = 100 + 5;
const int dir[8][2] = {
        {1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}
};

int A[maxN][maxN];
double dist[maxN][maxN];
bool inq[maxN][maxN];
int R, C;
int CS, RS, CT, RT;

void input()
{
    scanf("%d%d", &R, &C);
    for (int r = 0; r < R; r++)
        for (int c = 0; c < C; c++)
            scanf("%d", A[r] + c);
    scanf("%d%d%d%d", &CS, &RS, &CT, &RT);
}

inline int multi(int c1, int r1, int c2, int r2)
{
    return c1 * r2 - c2 * r1;
}

inline bool isValid(int r, int c)
{
    return r >= 0 && r < R && c >= 0 && c < C;
}

double spfa(int rs, int cs, int rt, int ct) //NOLINT
{
    using Pair = pair<int, int>;
    queue<Pair> que;
    que.emplace(rs, cs);
    memset(dist, 0x7f, sizeof(dist));
    dist[rs][cs] = 0.0;

    int curR, curC;
    while (!que.empty())
    {
        tie(curR, curC) = que.front();
        que.pop();
        inq[curR][curC] = false;
        for (int i = 0; i < 8; i++)
        {
            int nextR = curR + dir[i][0];
            int nextC = curC + dir[i][1];
            if (!isValid(nextR, nextC) ||
                    ((nextR != rt || nextC != ct) && multi(ct - cs, rt - rs, nextC - cs, nextR - rs) >= 0))
                continue;

            double len = A[nextR][nextC] +
                    (i < 4 ? 0.0 : (sqrt2 - 1.0) * (A[nextR][nextC] + A[curR][curC]));
            if (dist[curR][curC] + len < dist[nextR][nextC])
            {
                dist[nextR][nextC] = dist[curR][curC] + len;
                if (!inq[nextR][nextC])
                {
                    inq[nextR][nextC] = true;
                    que.emplace(nextR, nextC);
                }
            }
        }
    }
    return dist[rt][ct];
}

double solve()
{
    return spfa(RS, CS, RT, CT) + spfa(RT, CT, RS, CS);
}

int main()
{
    input();
    printf("%.2f", solve());
    return 0;
}