力扣第 341 场周赛

第1题：一最多的行

模拟

class Solution {
public:
    vector<int> rowAndMaximumOnes(vector<vector<int>> &g) {
        int m = g.size(), n = g[0].size();
        int r, mx = -1;
        for (int i = 0; i < m; i++) {
            int t = accumulate(g[i].begin(), g[i].end(), 0);
            if (t > mx) {
                mx = t;
                r = i;
            }
        }
        return {r, mx};
    }
};

第2题：找出可整除性得分最大的整数

还是模拟…

class Solution {
public:
    int maxDivScore(vector<int> &nums, vector<int> &divisors) {
        sort(divisors.begin(), divisors.end());
        int mx = -1, res;
        for (auto x: divisors) {
            int t = 0;
            for (auto v: nums)
                if (v % x == 0)
                    t++;
            if (t > mx) {
                mx = t;
                res = x;
            }
        }
        return res;
    }
};

第3题：构造有效字符串的最少插入数

计算对应的有效字符串由多少个"abc"组成

class Solution {
public:
    int addMinimum(string s) {
        int n = s.size();
        int m = 1;
        for (int i = 1; i < n; i++)
            if (s[i - 1] >= s[i])
                m++;
        return m * 3 - n;
    }
};

第4题：最小化旅行的价格总和

遍历每个trip:每个trip两点路径上的节点访问次数+1，得到各节点访问次数。可以设0为根，定义每个点有两种状态：一种是可以将当前节点减半情况下当前点为根的子树的最小价格和，一种是不能将当前节点减半情况下当前点为根的子树的最小价格和，通过记忆化搜索求解

class Solution {
public:
    vector<int> e[50];
    int cnt[50];
    stack<int> st;
    vector<int> price;
    int dp[50][2];

    void dfs(int s, int t, int p) {//当前节点s,终点t,父节点p
        st.push(s);
        if (s == t) {
            stack<int> temp = st;
            while (!temp.empty()) {
                cnt[temp.top()]++;
                temp.pop();
            }
            st.pop();
            return;
        }
        for (auto j: e[s])
            if (j != p)
                dfs(j, t, s);
        st.pop();
    }

    int get(int s, int p, int type) {//当前节点s,父节点p,type=0: 不能将当前节点减半，type=1: 可以将当前节点减半
        if (dp[s][type] != -1)
            return dp[s][type];
        if (type == 0) {
            dp[s][type] = cnt[s] * price[s];
            for (auto j: e[s])
                if (j != p) {
                    dp[s][type] += get(j, s, 1);
                }
            return dp[s][type];
        } else {
            int cur1 = cnt[s] * price[s] / 2;
            for (auto j: e[s])
                if (j != p) {
                    cur1 += get(j, s, 0);
                }
            int cur2 = cnt[s] * price[s];
            for (auto j: e[s])
                if (j != p) {
                    cur2 += get(j, s, 1);
                }
            return dp[s][type] = min(cur1, cur2);
        }
    }

    int minimumTotalPrice(int n, vector<vector<int>> &edges, vector<int> &price, vector<vector<int>> &trips) {
        for (auto &ei: edges) {
            e[ei[0]].push_back(ei[1]);
            e[ei[1]].push_back(ei[0]);
        }
        memset(cnt, 0, sizeof(cnt));
        for (auto &t: trips) {
            dfs(t[0], t[1], -1);
        }
        this->price = price;
        memset(dp, -1, sizeof(dp));
        return get(0, -1, 1);
    }
};