📂Atcoder

🔖DP 二分思维 Tarjan 二分图匈牙利算法最小路径覆盖二分图最大匹配

2024-10-05 22:55阅读: 831评论: 8推荐: 6

AtCoder Beginner Contest 374

省流版

A. 判断末三位即可
B. 逐位判断即可
C. 枚举所有分组情况即可
D. 枚举线段顺序、端点顺序即可
E. 二分答案，发现贵的机器数量不超过 $100$ ，枚举求最小花费看是否可行即可
F. 朴素DP，复杂度分析得到有效时刻不超过 $O(n^2)$ 而非 $O(s_i)$ ，直接 $DP$ 即可
G. 最小路径覆盖问题，建有向图、缩点、求传递闭包、二分图最大匹配即可

稍微完善了E题的证明
更新了G

A - Takahashi san 2 (abc374 A)

题目大意

给定一个字符串，问结尾是不是san

解题思路

直接判断最后三个字母即可，python可以一行。

神奇的代码

 print("Yes" if input().strip().endswith('san') else "No")

B - Unvarnished Report (abc374 B)

题目大意

给定两个字符串，问第一个字母不相同的次数。

解题思路

逐位判断即可。

python的想法，即先找出不同的位置，然后取最小值。

神奇的代码

 a = input().strip()
b = input().strip()
if len(a) > len(b):
    a, b = b, a
if len(a) < len(b):
    a += ' ' * (len(b) - len(a))
pos = [i for i in range(len(a)) if a[i] != b[i]]
if not pos:
    print(0)
else:
    print(pos[0] + 1)

C - Separated Lunch (abc374 C)

题目大意

给定 $n$ 个数字，分成两组，使得和最大值最小。

解题思路

$n \leq 20$ ，直接花 $O(2^n)$ 枚举分组情况，每种情况花 $O(n)$ 统计和，所有情况取最小值即可。总的时间复杂度为 $O(2^nn)$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a)
        cin >> x;
    int tot = accumulate(a.begin(), a.end(), 0);
    int up = (1 << n);
    int ans = 2e9 + 7;
    for (int i = 0; i < up; ++i) {
        int cnt = 0;
        for (int j = 0; j < n; ++j) {
            cnt += ((i >> j) & 1) * a[j];
        }
        ans = min(ans, max(cnt, tot - cnt));
    }
    cout << ans << '\n';
 
    return 0;
}

D - Laser Marking (abc374 D)

题目大意

二维平面，给定 $n$ 个线段，用激光打印机打印。

激光移动速率为 $s$ ，打印时的速率为 $t$ 。

规定打印顺序，使得耗时最短。初始激光位于 $(0,0)$ 。

解题思路

打印顺序，即规定打印线段的顺序，以及每个线段从哪个端点开始打印。

由于 $n \leq 6$ ，因此花 $O(n!)$ 枚举顺序，花 $O(2^n)$ 枚举线段的打印端点，然后花 $O(n)$ 计算时间即可。

总的时间复杂度为 $O(n!2^nn)$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, s, t;
    cin >> n >> s >> t;
    vector<array<int, 4>> a(n);
    for (auto& x : a) {
        cin >> x[0] >> x[1] >> x[2] >> x[3];
    }
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    double ans = 1e9 + 7;
    int up = (1 << n);
    auto dist = [](int x, int y, int sx, int sy) -> double {
        return sqrt((x - sx) * (x - sx) + (y - sy) * (y - sy));
    };
    auto solve = [&](vector<int>& id, int dir) -> double {
        int x = 0, y = 0;
        double res = 0;
        for (auto& i : id) {
            auto [sx, sy, ex, ey] = a[i];
            if ((dir >> i) & 1) {
                swap(sx, ex);
                swap(sy, ey);
            }
            res += dist(x, y, sx, sy) / s;
            res += dist(sx, sy, ex, ey) / t;
            x = ex;
            y = ey;
        }
        return res;
    };
    do {
        for (int i = 0; i < up; i++) {
            ans = min(ans, solve(id, i));
        }
    } while (next_permutation(id.begin(), id.end()));
    cout << fixed << setprecision(10) << ans << '\n';
 
    return 0;
}

E - Sensor Optimization Dilemma 2 (abc374 E)

题目大意

制作产品，有 $n$ 道工序。

每道工序有两种设备，单价 $p_i$ 和 $q_i$ ，一天可做 $a_i$ 和 $b_i$ 的产品。

最终的生产效率是所有工序的产品数量的最小值。

现有 $x$ 元，问生产效率的最大值。

解题思路

首先枚举这个最大值，然后看可不可行。容易发现生产效率越小越容易满足，越大越难满足，因此这个答案可以二分（典型的最小值最大）。

二分了生产效率 $m$ 后，剩下的问题就是让每一个工序的产能都 $\geq m$ ，且让花费最小，然后看所有的工序的花费是否 $\geq x$ 。

这里只有两种机器，一个朴素的想法就是计算单位产能的价格，即 $\frac{p_i}{a_i}$ 和 $\frac{q_i}{b_i}$ 看看那个小，那我们肯定买小的那个。

但是会有个问题，如果我们只买小的，然后产能刚好 $=m$ ，此时肯定是最优策略。但如果产能 $>m$ ，此时满足了 $\geq m$ ，但花费不见得是最小的：比如可以少买几个，多买另外的，使得产能刚好 $=m$ ，且花费比前面的还小（样例一就是个反例）。

假设 $a_i$ 的单价更低，上述考虑的是全买 $a_i$ 的，但不一定是花费最小的，退而求其次，买一些 $b_i$ 来替换 $a_i$ ，那我应该买多少个 $b_i$ 呢？

由于 $a_i, b_i \leq 100$ ，比赛时就直接猜的 $b_i$ 的范围就是 $1 \sim 100$ ，再大的话完全可以由等价的 $a_i$ 替换之类的。然后就过了。

现在细细想来，这里的问题即为 $a_i x + b_iy \geq m$ ，找到一个最好的 $(x,y)$ 满足该不等式，且 $p_i x + q_i y$ 最小。 $x,y$ 的范围都高达 $(10^7)$ ，直接遍历不现实，但我们知道 $x$ 尽可能大是最好的，因此这里的 $y$ 的范围不会很大，但有多小呢？

假设 $y=0$ 的情况，此时全买 $a_i$ ，最坏情况就是 $a_ix = m + a_i - 1$ ，产量超了太多，现在想通过买一些 $b_i$ 使得产量超标少一点，比如多一台 $b_i$ ，少几台 $a_i$ ，就能让超标量少 $1$ ，这样 $b_i$ 最多多买 $a_i-1$ 台，就能调整产能刚刚好 $=m$ 之类的。

或者从另一个角度来看，因为 $a_i$ 是尽可能多买，因此注意到最终的产量范围是 $[m, m + a_i - 1]$ ，这里只有 $a_i$ 个数，如果多买一台 $b_i$ ，少买几台 $a_i$ ，产量要么不变，要么变成另外的一个数（比如产量 $-2$ 了）。这里的另外的一个数最坏情况下只有 $a_i$ 种情况，因此 $y$ 的范围最多就到 $a_i$ ，就能遍历到可行的 $[m, m + a_i - 1]$ 中的所有情况了。注意这里可行的情况不一定是 $a_i$ 种，有可能一种（比如多买一台 $b_i$ ，少买几台 $a_i$ ，最终产量不变），也可能其他种（产量 $-1$ 就有 $a_i$ 种，如果 $-2$ 就可能只有一半的数能取到），具体多少种呢？其实就是 $\frac{a_i}{gcd(a_i, b_i)}$ ，但它们一定是 $a_i$ 的因子，因此 $y$ 直接遍历 $[0,a_i)$ 就一定能遍历到所有能取到的情况了（虽然可能有一些情况被多次考虑了），当然 $y$ 遍历 $[0, \frac{a_i}{gcd(a_i, b_i)})$ 也是正确的，这样所有的情况都只考虑一次了。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, x;
    cin >> n >> x;
    vector<array<int, 4>> a(n);
    for (auto& i : a) {
        cin >> i[0] >> i[1] >> i[2] >> i[3];
    }
    auto check = [&](int t) {
        LL sum = 0;
        for (auto& i : a) {
            auto [a, p, b, q] = i;
            if (1ll * p * b > 1ll * q * a)
                swap(a, b), swap(p, q);
            LL tmp = 1e9 + 7;
            for (int j = 0; j < a; ++j) { // j < a / gcd(a,b) 也可以
                LL cost = 1ll * max(0, (t - j * b + a - 1) / a) * p + j * q;
                tmp = min(tmp, cost);
            }
            sum += tmp;
        }
        return sum <= x;
    };
    int l = 0, r = 1e9 + 8;
    while (l + 1 < r) { // [l,r)
        int mid = (l + r) / 2;
        if (check(mid))
            l = mid;
        else
            r = mid;
    }
    cout << l << '\n';
 
    return 0;
}

F - Shipping (abc374 F)

题目大意

$n$ 个单，第 $i$ 个单从 $s_i$ 时刻可以接。

一次最多接 $k$ 个单，接了后 $x$ 时刻之后才能再接。

一个单的不满意度为接单时刻与可接时刻的差，即 $t_i - s_i$ 。

求最小的不满意度，

解题思路

这题难在复杂度分析。

朴素 $dp$ 即 $dp[i][j]$ 表示前 $i$ 时刻，完成了前 $j$ 个单的最小不满意度。但这里时刻数高达 $10^{12}$ ，不大行。

时刻数不能作为状态。但考虑上述状态，有非常多的显然不优的状态：我接单的时刻，只有两类：

我现在刚刚可以接单，就立刻接还在囤积的单。
或者我等等下一个单，然后一起接。

考虑这样的时刻数有多少：

第一类的时刻数，就是形如 $s_i + x + x + x...$ ，但注意到每 $+x$ ，必定有一个囤积的单，如果没有囤积的单，那下一个时刻就是第二类的（某个 $s_j$ ）。因此第一类的时刻数，对于每个 $i$ 来说只有 $O(n)$ 个，即最多有 $n$ 个 $+x$ 。因此总的时刻数就 $O(n^2)$ 个。
第二类的时刻数，显然就是 $O(n)$ 个。

所以，上述 $dp[i][j]$ 中的 $i$ ，抛去显然不优的状态，剩下的只有 $O(n^2)$ 个需要考虑的状态，加之 $j$ 有 $O(n)$ 状态，其状态数就是 $O(n^3)$ ，加之转移复杂度是 $O(k)$ ，总的时间复杂度就是 $O(n^3k)$ 。

转移考虑往后转移的方式，代码里，则为 $dp[i][j]$ 表示完成前 $i$ 个单，此时时刻为 $j$ 的最小不满意度，因为 $j$ 是离散的所以是个 $map$ 。然后枚举接下来完成的单的数量 $l$ ，计算不满意度转移即可。计算不满意度即 $\sum t - s_i$ ，可以用前缀和优化，或者枚举 $l$ 时维护 $\sum s_i$ 。

标准写法500ms

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k, x;
    cin >> n >> k >> x;
    vector<LL> t(n);
    for (auto& i : t)
        cin >> i;
    vector<LL> sum(n);
    partial_sum(t.begin(), t.end(), sum.begin());
    vector<map<LL, LL>> dp(n + 1);
    dp[0][0] = 0;
    auto get_sum = [&](int l, int r) {
        if (l > r)
            return 0ll;
        return sum[r] - (l ? sum[l - 1] : 0);
    };
    for (int i = 0; i < n; ++i) {
        for (auto& [now, val] : dp[i]) {
            int st = i;
            for (int j = 1; j <= k && i + j <= n; ++j) {
                int ed = st + j;
                LL cur = max(now, t[ed - 1]);
                LL nxt = val + j * cur - get_sum(st, ed - 1);
                if (dp[i + j].count(cur + x)) {
                    dp[i + j][cur + x] = min(dp[i + j][cur + x], nxt);
                } else {
                    dp[i + j][cur + x] = nxt;
                }
            }
        }
    }
    LL ans = 1e18 + 7;
    for (auto& [_, val] : dp[n]) {
        ans = min(ans, val);
    }
    cout << ans << '\n';
 
    return 0;
}

下面的是比赛时写的，加了点小小的转移优化，省去了一些不必要的转移（即囤积的单肯定全部处理）。

赛场时写的稍加优化的1ms

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k, x;
    cin >> n >> k >> x;
    vector<LL> t(n);
    for (auto& i : t)
        cin >> i;
    vector<LL> sum(n);
    partial_sum(t.begin(), t.end(), sum.begin());
    vector<map<LL, LL>> dp(n + 1);
    dp[0][0] = 0;
    auto get_sum = [&](int l, int r) {
        if (l > r)
            return 0ll;
        return sum[r] - (l ? sum[l - 1] : 0);
    };
    for (int i = 0; i < n; ++i) {
        for (auto& [now, val] : dp[i]) {
            int st = i;
            int ed = upper_bound(t.begin(), t.end(), now) - t.begin(); // 囤积的单
            int cnt = max(1, ed - st);
            for (int j = min(k, cnt); j <= k && i + j <= n; ++j) { // 囤积的单肯定全部处理
                ed = st + j;
                LL cur = max(now, t[ed - 1]);
                LL nxt = val + j * cur - get_sum(st, ed - 1);
                if (dp[i + j].count(cur + x)) {
                    dp[i + j][cur + x] = min(dp[i + j][cur + x], nxt);
                } else {
                    dp[i + j][cur + x] = nxt;
                }
            }
        }
    }
    LL ans = 1e18 + 7;
    for (auto& [_, val] : dp[n]) {
        ans = min(ans, val);
    }
    cout << ans << '\n';
 
    return 0;
}

G - Only One Product Name (abc374 G)

题目大意

给定 $n$ 个长度为 $2$ 的大写字符串，构造一个字符串列表，满足每个大写字符都作为子串出现在这列表里，且列表里每个字符串的 $2$ 字母子串都是这 $n$ 个字符串里的，即出现的都在子串里，子串里的都出现了。

问这个列表的字符串数量的最小值。

解题思路

显然答案的下界就是 $n$ ，即每个字符串都在这个列表里。

如何让答案更小呢？那就是可以将其拼接，比如两个字符串AB和BC拼接起来，得到ABC，这样仍能满足题意条件，且该字符串列表的字符串数量减少了一个。

这启发我们考虑如何拼接，将每个字符串看作图的点，两个字符串 $u,v$ 可以拼接，则一条有向边 $u \to v$ 。

每一条有向边就是一次拼接，一条路径就是拼接多次，也就对应字符串列表里的一个字符串。

因此问题转换成，用最少的路径，覆盖所有顶点。注意这里的路径的点可以重复，同时也可以相互相交。

著名的最小路径覆盖是适用于 $DAG$ 的，而这里有环，但因为一条路径的点可以重复，因此可以先用Tarjan将环缩成一个点，得到一张DAG，剩下的问题就是一个最小可相交路径覆盖问题，就是套路了。

关于套路的理解，首先得明白最小不相交路径覆盖与二分图最大匹配的关系：因为路基不能相交，可以理解成每个点只能有一个入度和出度，因此每个点拆成两个点，代表出度和入度分居两边，一个匹配就是一个点的出度和一个点的入度匹配，即选了一条有向边，即拼接了一次，答案减一。而最大匹配就对应了最小答案。

理解了匹配的意义，来看可相交的情况下，此时每个点不一定只有一个入度和出度，但有多少个无所谓，我们只关心一条路径的起点和终点，中间的无所谓覆盖过与否，因此如果两点 $u \to v$ 可通过若干个中间点可达，无所谓，我们直接连一条 $u \to v$ 的边即可，一旦匹配到这条边，意味着有一条路径 $u \to v$ ，中间的点是什么无所谓，因为可以重复覆盖。而这是一个传递闭包（可达性）。

总体而言，

根据拼接关系建立有向图
用Tarjan将环收缩成点后重建新图（转成 $DAG$ ）
新图跑一遍floyd得到可达性的闭包，根据可达性建立新图（两点可达则有边）
将新图转换成二分图，求最大匹配，答案即为 点数-匹配数

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<string> s(n);
    for (auto& i : s)
        cin >> i;
    vector<vector<int>> G(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (s[i].back() == s[j].front())
                G[i].push_back(j);
        }
    }
 
    // SCC
    vector<int> low(n), dfn(n), belong(n), in(n);
    vector<vector<int>> bcc;
    int clk = 0;
    auto tarjan = [&](auto&& tarjan, int u) -> void {
        static stack<int> st;
        dfn[u] = low[u] = ++clk;
        st.push(u);
        in[u] = true;
        for (int& v : G[u]) {
            if (!dfn[v]) {
                tarjan(tarjan, v);
                low[u] = min(low[u], low[v]);
            } else if (in[v])
                low[u] = min(low[u], dfn[v]);
        }
        if (dfn[u] == low[u]) {
            vector<int> tmp;
            while (1) {
                int x = st.top();
                st.pop();
                in[x] = false;
                belong[x] = bcc.size();
                tmp.push_back(x);
                if (x == u)
                    break;
            }
            bcc.push_back(tmp);
        }
    };
    for (int i = 0; i < n; ++i) {
        if (!dfn[i])
            tarjan(tarjan, i);
    }
 
    // reconstract
    int m = bcc.size();
    vector<vector<int>> edge(m, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (auto j : G[i]) {
            if (belong[i] != belong[j])
                edge[belong[i]][belong[j]] = 1;
        }
    }
 
    // floyd
    for (int k = 0; k < m; ++k) {
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < m; ++j) {
                if (i == j)
                    continue;
                if (edge[i][k] && edge[k][j])
                    edge[i][j] = 1;
            }
        }
    }
 
    // augmenting path
    vector<int> vis(m), pa(m, -1);
    int tt = 0;
    function<bool(int)> dfs = [&](int u) {
        vis[u] = tt;
        for (int v = 0; v < m; ++v) {
            if (edge[u][v] &&
                (pa[v] == -1 || (vis[pa[v]] != tt && dfs(pa[v])))) {
                pa[v] = u;
                return true;
            }
        }
        return false;
    };
    int ans = 0;
    for (int i = 0; i < m; ++i) {
        ++tt;
        if (dfs(i))
            ++ans;
    }
 
    cout << m - ans << '\n';
 
    return 0;
}

本文作者：~Lanly~

本文链接：https://www.cnblogs.com/Lanly/p/18448640

posted @ 2024-10-05 22:55 ~Lanly~ 阅读(831) 评论(8) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：~Lanly~ 园龄：8年3个月粉丝：300 关注：55

昵称： ~Lanly~
园龄： 8年3个月
粉丝： 300
关注： 55

+加关注

指尖跃动的换行符，是我此生不变的信仰。|

2025年3月

日

一

二

三

四

五

六

~Lanly~

指尖跃动的换行符，是我此生不变的信仰。

AtCoder Beginner Contest 374

A - Takahashi san 2 (abc374 A)

题目大意

解题思路

B - Unvarnished Report (abc374 B)

题目大意

解题思路

C - Separated Lunch (abc374 C)

题目大意

解题思路

D - Laser Marking (abc374 D)

题目大意

解题思路

E - Sensor Optimization Dilemma 2 (abc374 E)

题目大意

解题思路

F - Shipping (abc374 F)

题目大意

解题思路

G - Only One Product Name (abc374 G)

题目大意

解题思路

公告

我的标签

随笔分类

随笔档案

友情链接

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	a = input().strip()
	b = input().strip()
	if len(a) > len(b):
	a, b = b, a
	if len(a) < len(b):
	a += ' ' * (len(b) - len(a))
	pos = [i for i in range(len(a)) if a[i] != b[i]]
	if not pos:
	print(0)
	else:
	print(pos[0] + 1)

	#include <bits/stdc++.h>
	using namespace std;
	using LL = long long;

	int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int n;
	cin >> n;
	vector<int> a(n);
	for (auto& x : a)
	cin >> x;
	int tot = accumulate(a.begin(), a.end(), 0);
	int up = (1 << n);
	int ans = 2e9 + 7;
	for (int i = 0; i < up; ++i) {
	int cnt = 0;
	for (int j = 0; j < n; ++j) {
	cnt += ((i >> j) & 1) * a[j];
	}
	ans = min(ans, max(cnt, tot - cnt));
	}
	cout << ans << '\n';

	return 0;
	}