SMU Summer 2024 Contest Round 6

已于 2024-07-23 13:07:05 修改
阅读量827 收藏 12
点赞数 25
文章标签： 深度优先 算法
于 2024-07-23 13:06:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73914071/article/details/140628857
版权

Many Formulas

思路：字符串最多 10 10 10位，所以直接所有加号在哪个位置

void solve() {
    string s; cin >> s;
    int n = s.size() - 1;
    int ans = 0;
    for (int i = 0; i < (1 << n); i ++) {
        string str = s;
        int c = 0;
        for (int j = 0; j < n; j ++) {
            if (i >> j & 1) {
                str = str.substr(0, j + 1 + c) + '+' + str.substr(j + 1 + c);
                c ++;
            }
        }
        stack<int> stk;
        bool ok = false;
        for (int j = 0; j < str.size(); j ++) {
            int k = j;
            int sum = 0;
            if (str[j] >= '0' && str[j] <= '9') {
                while (str[k] >= '0' && str[k] <= '9' && k < str.size()) {
                    sum = sum * 10 + (str[k] - '0');
                    k ++;
                }
                j = k - 1;
                stk.push(sum);
            }
            if (!ok) {
                if (str[j] == '+') ok = true;
            } else {
                int x = stk.top(); stk.pop();
                int y = stk.top(); stk.pop();
                stk.push(x + y);
                ok = false;
            }
        }
        ans += stk.top();
    }
    cout << ans << '\n';
}

[Tak and Cards]http://162.14.124.219/contest/1010/problem/B()

思路：背包 d p dp dp， d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k]表示前 i i i个物品中选 j j j个物品凑出总和为 k k k的方案数，可以将第一维优化，题目内存够，没必要，记得初始化选零个，体积为零时候的方案数，之后直接按照背包 d p dp dp进行转移即可

int dp[N][N][N * N];

void solve() {
    int n, A; cin >> n >> A;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
    }
    int ans = 0;
    for (int i = 0; i <= n; i ++) dp[i][0][0] = 1, dp[i][0][1] = dp[i][1][0] = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= i; j ++) {
            for (int k = 1; k <= 2500; k ++) {
                dp[i][j][k] = dp[i - 1][j][k];
                if (k >= a[i]) dp[i][j][k] += dp[i - 1][j - 1][k - a[i]];
            }
        }
    }
    for (int i = 1; i <= n; i ++) {
        ans += dp[n][i][i * A];
    }
    cout << ans << '\n';
}

Wall

思路：求两个点之间的最短路，数据范围小，直接 O ( n 3 ) O(n^3) O(n3)的 f l o y d floyd floyd即可

`int g[11][11];

void solve() {
    int n, m; cin >> n >> m;
    vector<vector<int>> dp(11, vector<int> (11, INF));
    for (int i = 0; i <= 9; i ++) {
        for (int j = 0; j <= 9; j ++) {
            cin >> dp[i][j];
        }
    }
    for (int k = 0; k < 10; k ++) {
        for (int i = 0; i < 10; i ++) {
            for (int j = 0; j < 10; j ++) {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
            }
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= m; j ++) {
            int x; cin >> x;
            if (x != -1 && x != 1) ans += dp[x][1];
        }
    }
    cout << ans << '\n';
}

Coloring Edges on Tree

思路：直接 d f s dfs dfs就行，每次染色都从 1 1 1开始，只要和这个点的父节点练的那条边的颜色不一样就行

void solve() {
    int n; cin >> n;
    vector<vector<int>> g(n + 1);
    vector<array<int, 2>> a(n + 1);
    vector<int> fa(n + 1);
    for (int i = 1; i < n; i ++)  {
        int u, v; cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
        a[i] = {u, v};
    }
    int cnt = 0;
    map<array<int, 2>, int> mp;
    auto dfs = [&](auto && dfs, int u, int f) -> void {
        int idx = 0, ii = mp[{f, u}];
        for (auto v : g[u]) {
            if (v == f) continue;
            idx ++;
            if (idx == ii) idx ++;
            mp[{u, v}] = idx;
            dfs(dfs, v, u);
        }
        cnt = max(idx, cnt);
    };
    dfs(dfs, 1, 0);
    cout << cnt << '\n';
    for (int i = 1; i < n; i ++) {
        cout << mp[ {a[i][0], a[i][1]}] << '\n';
    }
}

Fault-tolerant Network

思路：本质上要让所有电脑联通，只需要将第一行的 1 1 1和 n n n两个点和下面一行连起来，第二行的 1 1 1和 n n n两个点和第一行连起来就行，先分别求出来四个顶点连到对应行的最小值，要注意有可能第一行和第二行的直接连接端点的情况

void solve() {
    cnt ++;
    int n; cin >> n;
    vector<int> a(n + 1), b(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
    }
    for (int i = 1; i <= n; i ++) {
        cin >> b[i];
    }
    int ans = abs(a[1] - b[1]) + abs(a[n] - b[n]), t;
    int r1, r2, r3, r4;
    r1 = r2 = r3 = r4 = INF;
    for (int i = 1; i <= n; i ++) r1 = min(r1, abs(a[1] - b[i])), r2 = min(r2, abs(a[n] - b[i]));
    for (int i = 1; i <= n; i ++) r3 = min(r3, abs(b[1] - a[i])), r4 = min(r4, abs(b[n] - a[i]));
    ans = min(ans, r1 + r2 + r3 + r4);
    ans = min(ans, abs(a[1] - b[1]) + r2 + r4);
    ans = min(ans, abs(a[n] - b[n]) + r1 + r3);
    ans = min(ans, abs(a[1] - b[n]) + abs(a[n] - b[1]));
    ans = min(ans, abs(a[1] - b[n]) + r2 + r3);
    ans = min(ans, abs(a[n] - b[1]) + r1 + r4);
    cout << ans << '\n';
}

Nearest Excluded Points

思路：先找出距离已知点为 1 1 1的点，记录答案，放到队列里面，然后按照正常的 b f s bfs bfs更新就行，只有遇到这个点没有被记录答案并且是题目给的点，就更新答案，放到队列里面，这个点的答案就是由前面拓展点的答案，因为 b f s bfs bfs第一次遇见一定是最短的

int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};

void solve() {
    int n; cin >> n;
    map<pair<int, int>, int> vis;
    map<pair<int, int>, pair<int, int>> ans;
    vector<pair<int, int>> a(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i].first >> a[i].second;
        vis[ {a[i].first, a[i].second}] = 1;
    }
    queue<pair<int, int>> q;
    for (int i = 1; i <= n; i ++) {
        for (int j = 0; j < 4; j ++) {
            int x = a[i].first + dx[j];
            int y = a[i].second + dy[j];
            if (!vis.count({x, y})) {
                q.push({a[i].first, a[i].second});
                ans[ {a[i].first, a[i].second}] = {x, y};
            }
        }
    }
    while (q.size()) {
        auto [x, y] = q.front();
        q.pop();
        for (int j = 0; j < 4; j ++) {
            int tx = x + dx[j];
            int ty = y + dy[j];
            if (vis.count({tx, ty}) && !ans.count({tx, ty})) {
                ans[ {tx, ty}] = ans[ {x, y}];
                vis[ {tx, ty}] = 1;
                q.push({tx, ty});
            }
        }
    }
    for (int i = 1; i <= n; i ++) {
        auto [t1, t2] = ans[ {a[i].first, a[i].second}];
        cout << t1 << ' ' << t2 << '\n';
    }
}

Vacation Query

思路：类似线段树维护最大字段和，这个题的区间修改是把区间进行取反操作，但我们不用真的进行取反操作，只用记录每个区间里连续 0 0 0， 1 1 1的最大值就行，进行取反的时候交换这个区间里面维护 0 0 0， 1 1 1数量的变量的值就相当于取反了，这个思路太巧秒了


template<class T>
struct SegmentTree {
#define ls u << 1
#define rs u << 1 | 1
    struct Info {
        int l, r;
        int op;
        T mx0, mx1;
        T lsum0, lsum1;
        T rsum0, rsum1;
    };
    vector<Info> tr;
    vector<T> a;
    SegmentTree(const vector<T> &init) {
        int n = init.size() - 1;
        tr.resize(n * 4 + 1);
        a = init;
        build(1, 1, n);
    }
    Info merge(Info &u, Info l, Info r) {
        int lvl = l.r - l.l + 1;
        int rvl = r.r - r.l + 1;

        u.mx0 = max({l.mx0, r.mx0, l.rsum0 + r.lsum0});
        u.mx1 = max({l.mx1, r.mx1, l.rsum1 + r.lsum1});

        if (lvl == l.lsum0) u.lsum0 = l.lsum0 + r.lsum0;
        else u.lsum0 = l.lsum0;
        if (lvl == l.lsum1) u.lsum1 = l.lsum1 + r.lsum1;
        else u.lsum1 = l.lsum1;

        if (rvl == r.rsum0) u.rsum0 = l.rsum0 + r.rsum0;
        else u.rsum0 = r.rsum0;
        if (rvl == r.lsum1) u.rsum1 = l.rsum1 + r.rsum1;
        else u.rsum1 = r.rsum1;

        return u;
    }
    void calc(Info &u) {
        swap(u.mx0, u.mx1);
        swap(u.lsum0, u.lsum1);
        swap(u.rsum0, u.rsum1);
        u.op ^= 1;
    }
    void pushup(int u) {
        // debug1(u);
        tr[u] = merge(tr[u], tr[ls], tr[rs]);
    }
    void pushdown(int u) {
        auto [_, __, op, _1, _2, _3, _4, _5, _6] = tr[u];
        if (op) {
            calc(tr[ls]);
            calc(tr[rs]);
            tr[u].op ^= 1;
        }
    }
    void build(int u, int l, int r) {
        if (!a[l]) tr[u] = {l, r, 0, 1, 0, 1, 0, 1, 0};
        else tr[u] = {l, r, 0, 0, 1, 0, 1, 0, 1};
        if (l == r) return ;
        int mid = l + r >> 1;
        build(ls, l, mid);
        build(rs, mid + 1, r);
        pushup(u);
    }
    void modify(int u, int l, int r) {
        if (tr[u].l >= l && tr[u].r <= r) {
            calc(tr[u]);
            return ;
        }
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(ls, l, r);
        if (r > mid) modify(rs, l, r);
        pushup(u);
    }
    Info query(int u, int l, int r) {
        if (tr[u].l >= l && tr[u].r <= r) return tr[u];
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(ls, l, r);
        if (l > mid) return query(rs, l, r);
        Info t = merge(t, query(ls, l, r), query(rs, l, r));
        pushup(u);
        return t;
    }
};

void solve() {
    int n, q; cin >> n >> q;
    string s; cin >> s;
    vector<int> a(n + 1);
    for (int i = 0; i < s.size(); i ++) {
        a[i + 1] = (s[i] == '1');
    }
    SegmentTree<int> sg(a);
    while (q --) {
        int c, l, r; cin >> c >> l >> r;
        if (c == 1) {
            sg.modify(1, l, r);
        } else {
            cout << sg.query(1, l, r).mx1 << '\n';
        }
    }
}
north_h
关注
  • 25
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SMU板卡-综合文档
05-24
Kesight SMU
ADI SMU
05-07
ADI多通道SMU资源
SMU Summer 2024 Contest Round 6 ABC题解
qq_39804992的博客
07-23 138
题意:给一个由数字组成的字符串,可在其中加任意个‘+’ 求所有情况之和思路:二进制枚举,有s个数字就有2^(s-1)种情况。
SMU Summer 2024 Contest Round 6补题情况
2301_80357816的博客
07-23 995
1234中1，4出现4次，2，3，12，34各2次，23，123，234各一次；因此发现规律，实际上从单个数字开始，头尾的两个数字出现的次数是1<<k(k=s.size()-2)，中间的数字为k/2次，当数字每增加一位k就要除2，以此类推。将一个无向图变为有向图，然后查找每一个节点的度数，找出最大度，从最大度的结点开始bfs，每一个节点不能连接两个相同的颜色，且每一个节点在bfs的时候都要知道颜色是从1开始进行标记的。每一次枚举的时候，遇到1或者是最后一位的时候就进行断开，并将当前的数字进行加和。
SMU Summer 2024 Contest Round 5
qq_42643660的博客
07-19 1296
偏爱dp，方案数-封阻暴搜，建边跑最短路
SMU Summer 2024 Contest Round 3
qq_42643660的博客
07-14 855
时间戳，鸽巢原理，最短路变种，简单dp
SMU Summer 2024 Contest Round 2
FS_tar的博客
07-09 502
本来想直接暴力k的，0——6，3的六次方有点太大了，可以循环每个即可，一个比较简单的模拟。N个产品，每个产品在T【i】时间持续D【i】秒经过打印机，可以接受打印，打印是一瞬间的事但打印完需要冷却一秒。n个长度为l【i】的单词，每个单词间隔一空，行首不用间隔，给定最多m行，求窗口最小宽度。对着这题目和题解得有将近四小时吧，看的还是很懵而且对着答案一直在改，给我改麻木了已经。给定长度为n的字符串s，q个询问，求在l到r的范围内有多少组俩个连续字符。给出数字k，每9个循环，中间镂空，具体输出见示例。
SMU Summer 2024 Contest Round 1
FS_tar的博客
07-09 369
分俩种情况考虑，抛掷数直接大于等于k，以及第一次并未大于等于k，后抛硬币的失败几率是2的n次方乘以它本身，用到log和pow函数，函数不熟悉以及注意小数单位即可。可以想到所有节点跟1个节点相连时，可以得到最大k是（i-1）*（i-2）/2，每俩个节点之间连上一条线，就会少一种情况，就可以得出代码。注意一个地方，不要遇到树就走，很多是思维问题，其实可以尝试的，联通块之类的同理，也会以dfs居多。第一道就做的这个，用了multiset，tle了，优先队列不太熟悉，加上时间不太够，没做出来。
SMU Summer 2024 Contest Round 4
weixin_73914071的博客
07-17 689
思路：先把绿色和红色苹果那尽可能大的放到优先队列里面，如何将无色的苹果从小到大排序遍历，将能替换的全部替换。，调和及数的复杂度，正解就是每个因子的数量是一个等差数列，最后推出来一个公式，后面再说。思路：枚举每一行和每一列染成红色还是保持原样，直接二进制枚举验证答案就行。思路：这个题可以直接求每个数的因子数量，整体的复杂度是。存下来，然后用一个类似于滑动窗口的思想，动态维护。，因此，我们先把计算出所有得。思路：把题目意思转化为公式。将首的数字的贡献减去。个数，当滑窗内的数字超过。
SMULib.rar_SMU_remote
09-20
标题中的"SMULib.rar_SMU_remote"表明这是一个与SMU（Signal Measurement Unit，信号测量单元）相关的库，主要用于远程控制。SMU是一种常见的电子测试设备，能够提供精确的电压和电流，常用于半导体器件、电路和材料...
B2900ASeriesPrecisionSourceMeasureUnitDataSheet_SMU.pdf
06-20
Keysight B2900A 系列提供超大的量測速率，並支援傳統的 SMU SCPI 指令集，可輕鬆實現測試程式碼的轉移。將 SMU 整合入產品測試系統時，這些功能將提高測試效率並降低擁有成本。
B2900ASeriesPrecisionSourceMeasureUnitUserGuide_SMU.pdf
06-20
本手冊說明「Keysight Technologies B2900 精準來源 / 量測設備」 (SMU) 的前面 板操作、安裝與功能。
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5131
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
算法-KMP字符串匹配
xx_xb的博客
07-23 177
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 660
AtCoder Beginner Contest 363 ABCDE
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 853
环形链表
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 756
二叉搜索树向左或向右指明方向，不用遍历整个树。
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 513
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值