LCCUP‘23 力扣杯春季编程大赛 - 个人赛 A-D

A:补给马车

模拟

class Solution {
public:
    vector<int> supplyWagon(vector<int> &a) {
        int n = a.size();
        int m = n / 2;
        for (int i = n; i > m; i--) {
            int mn = INT32_MAX, k;
            for (int j = 1; j < i; j++) {
                if (a[j - 1] + a[j] < mn) {
                    k = j;
                    mn = a[j - 1] + a[j];
                }
            }
            a[k - 1] += a[k];
            for (int j = k; j < i - 1; j++)
                a[j] = a[j + 1];
        }
        vector<int> res;
        for (int i = 0; i < m; i++)
            res.push_back(a[i]);
        return res;
    }
};

B:探险营地

还是模拟~

class Solution:
    def adventureCamp(self, a: List[str]) -> int:
        d = set(a[0].split("->"))
        res = -1
        mx = 0
        for i in range(1, len(a)):
            t = set()
            li = a[i].split("->")
            for si in li:
                if si != "":
                    if si not in d:
                        t.add(si)
            if len(t) > mx:
                mx = len(t)
                res = i
            d |= t
        return res

C:最强祝福力场

暴力枚举：首先可以知道一定存在这样的一个点，它是两个正方形的“上下边之一”与“左右边之一”的交点，使得在这一点处得到最强力场。所以我们可以枚举两个正方行的“上下边之一”与“左右边之一”的组合，并遍历正方形计算每种组合产生交点的强度

class Solution {
public:
    typedef long long ll;

    int fieldOfGreatestBlessing(vector<vector<int>> &g) {
        int res = 1;
        auto get_bound = [&](vector<int> &a) -> tuple<ll, ll, ll, ll> {//返回边界数值*2，可以避免小数
            return {1LL * a[0] * 2 - a[2], 1LL * a[0] * 2 + a[2], 1LL * a[1] * 2 - a[2], 1LL * a[1] * 2 + a[2]};//up,down,left,right
        };
        int n = g.size();
        ll u[n], d[n], l[n], r[n];
        for (int i = 0; i < n; i++) {
            auto [u1, d1, l1, r1] = get_bound(g[i]);
            u[i] = u1;
            d[i] = d1;
            l[i] = l1;
            r[i] = r1;
        }

        auto getloc = [&](int i, int j, int dir) -> tuple<ll, ll> {//“上下边之一”与“左右边之一”的组合
            if (dir == 0)
                return {u[i], l[j]};
            else if (dir == 1)
                return {u[i], r[j]};
            else if (dir == 2)
                return {d[i], l[j]};
            else
                return {d[i], r[j]};
        };
        for (int d_id = 0; d_id < 4; d_id++) {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++) {
                    auto [row, col] = getloc(i, j, d_id);
                    int t = 0;
                    for (int k = 0; k < n; k++) {
                        if (u[k] <= row && row <= d[k] && l[k] <= col && col <= r[k])
                            t++;
                    }
                    res = max(res, t);
                }
        }
        return res;
    }
};

D:传送卷轴

二分+bfs：首先预处理每个位置到终点的距离，再求每个可镜像位置镜像后与终点的最大距离(从守护者的角度会选最大)glass_d。针对每一条起点到终点的路径path_i，守护者会选择在其中glass_d最大的点进行镜像，所以问题求的是min{max{glass_d|glass_d in path_i}| path_i}可以用二分来枚举答案

class Solution {
public:
    inline bool legal(int nr, int nc, int m, int n) {//判断当前位置是否合法
        return nr >= 0 && nr < m && nc >= 0 & nc < n;
    }

    inline pair<int, int> g1(int r, int c, int m, int n) {//上下镜像位置
        return {m - 1 - r, c};
    }

    inline pair<int, int> g2(int r, int c, int m, int n) {//左右镜像位置
        return {r, n - 1 - c};
    }

    int challengeOfTheKeeper(vector<string> &g) {
        int m = g.size(), n = g[0].size();
        int dr[4] = {1, -1, 0, 0};
        int dc[4] = {0, 0, 1, -1};
        int inf = 1e6;
        int dis[m][n];
        int sr, sc, er, ec;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                dis[i][j] = inf;
                if (g[i][j] == 'S') {
                    sr = i;
                    sc = j;
                } else if (g[i][j] == 'T') {
                    er = i;
                    ec = j;
                }
            }
        queue<pair<int, int>> q;
        dis[er][ec] = 0;
        q.emplace(er, ec);
        while (!q.empty()) {//求每个非墙位置与终点的距离
            auto [rt, ct] = q.front();
            q.pop();
            for (int i = 0; i < 4; i++) {
                int nr = rt + dr[i];
                int nc = ct + dc[i];
                if (!legal(nr, nc, m, n) || g[nr][nc] == '#' || dis[nr][nc] != inf)continue;
                dis[nr][nc] = dis[rt][ct] + 1;
                q.emplace(nr, nc);
            }
        }
        int glass_d[m][n];
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {//glass_d:可镜像位置镜像后与终点的最大距离，若为inf说明达到该点则无法到达终点
                if (g[i][j] != '.')continue;
                auto [nr1, nc1] = g1(i, j, m, n);
                glass_d[i][j] = -1;
                if (g[nr1][nc1] != '#') {
                    glass_d[i][j] = max(glass_d[i][j], dis[nr1][nc1]);
                }
                auto [nr2, nc2] = g2(i, j, m, n);
                if (g[nr2][nc2] != '#') {
                    glass_d[i][j] = max(glass_d[i][j], dis[nr2][nc2]);
                }
            }
        int stoe = 0;
        int vis[m][n];
        memset(vis, 0, sizeof(vis));
        vis[sr][sc] = 1;
        q.emplace(sr, sc);


        int l = 0, r = m * n;
        while (l < r) {//二分枚举答案
            int mid = (l + r) / 2;
            stoe = 0;
            memset(vis, 0, sizeof(vis));
            vis[sr][sc] = 1;
            q.emplace(sr, sc);//判断是否参在满足这样的路径，使得这条路径上可镜像位置的mx_glass_d<=mid恒成立，实现采用bfs即可
            while (!q.empty()) {
                auto [rt, ct] = q.front();
                q.pop();
                for (int i = 0; i < 4; i++) {
                    int nr = rt + dr[i];
                    int nc = ct + dc[i];
                    if (nr == er && nc == ec)
                        stoe = 1;
                    if (!legal(nr, nc, m, n) || g[nr][nc] == '#' || glass_d[nr][nc] > mid || vis[nr][nc])continue;
                    vis[nr][nc] = 1;
                    q.emplace(nr, nc);
                }
            }
            if (stoe)
                r = mid;
            else
                l = mid + 1;
        }
        return l == m * n ? -1 : l;
    }
};