AtCoder Regular Contest 173 A~D

最新推荐文章于 2024-10-01 04:50:10 发布

AC-Panda

最新推荐文章于 2024-10-01 04:50:10 发布

阅读量1k

点赞数 20

分类专栏： AtCoder 文章标签：算法 ACM-ICPC OI atcoder

本文链接：https://blog.csdn.net/Code_Shark/article/details/136839247

版权

AtCoder 专栏收录该内容

61 篇文章 3 订阅

订阅专栏

A.Neq Number（数位 dp+二分）

题意：

正整数 $X$ 如果满足以下条件，则称 $N e q$ 数：

当 $X$ 用十进制符号书写时，没有两个相邻的字符是相同的。

例如， $1$ 、 $173$ 和 $9090$ 是 $N e q$ 数，而 $22$ 和 $6335$ 不是。

给你一个正整数 $K$ 。求第 $K$ 小的 $N e q$ 数。

分析：

考虑计算小于等于 $k$ 的 $N e q$ 数有多少个，利用二分枚举 $mi d$ ，用数位 $d p$ 计算小于等于 $mi d$ 的 $N e q$ 数有多少个，判断条件为相邻两位不同。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
LL dp[20][15], a[15];

LL dfs(int pos, int pre, bool limit, bool flag) {
    if (pos == 0)
        return 1;
    if (!limit && !flag && dp[pos][pre] != -1)
        return dp[pos][pre];
    LL mx = 9, ans = 0;
    if (limit)
        mx = a[pos];
    for (int i = 0; i <= mx; i++) {
        if (!flag && i == pre)
            continue;
        ans += dfs(pos - 1, i, limit & (i == mx), flag && (i == 0));
    }
    if (!limit && !flag)
        dp[pos][pre] = ans;
    return ans;
}

LL get(LL x) {
    LL tot = 0;
    while (x)
        a[++tot] = x % 10, x /= 10;
    return dfs(tot, 0, 1, 1);
}

int main() {
    memset(dp, -1, sizeof(dp));
    LL t;
    cin >> t;
    while (t--) {
        LL x;
        cin >> x;
        LL l = 0, r = 1e18, mid, ans;
        while (l <= r) {
            mid = (l + r) / 2;
            if (get(mid) <= x)
                ans = mid, l = mid + 1;
            else
                r = mid - 1;
        }
        cout << ans + 1 << endl;
    }
    return 0;
}

B.Make Many Triangles（数学）

题意：

在一个二维平面上有 $N$ 个不同的点。第 $i$ 个点的坐标是 $x_i,y_i)$ 。
以这些点为顶点创建尽可能多的（非退化）三角形。在这里，同一个点不能作为多个三角形的顶点。求最多可创建的三角形个数。
非退化三角形是指三个顶点不相交的三角形。

分析：

设 $l$ 为平面上穿过点数最多的直线, 其上点数为 $m$ :

$\ge n - \lfloor \frac{n}{3} \rfloor +1$ ，答案为 $n - m$ ，每从 $l$ 外取一个点，再从 $l$ 上选择两个点构成一个三角形。

$\le n - \lfloor \frac{n}{3}\rfloor$ ，答案可以取到上界 $\lfloor \frac{n}{3} \rfloor$

求出平面上穿过点数最多的直线上点的个数，二者取小即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
LL n, tmp, x[305], y[305];

bool check(LL ax, LL ay, LL bx, LL by, LL cx, LL cy) {
    return (bx - ax) * (cy - by) == (by - ay) * (cx - bx);
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> x[i] >> y[i];
    for (int i = 1; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            LL cnt = 2;
            for (int k = 1; k <= n; k++) {
                if (k == i || k == j)
                    continue;
                if (check(x[i], y[i], x[j], y[j], x[k], y[k]))
                    cnt++;
            }
            tmp = max(tmp, cnt);
        }
    }
    cout << min(n / 3, n - tmp) << endl;
    return 0;
}

C.Not Median（思维）

题意：

给你一个从 $1$ 到 $n$ 的整数排列 $P=(P_1,P_2,\dots,P_N)$ 。

对于每个 $i=1,2,\dots,N$ ，输出满足以下所有条件的一对整数 $(l, r)$ 的 $r - l + 1$ 的最小值。如果不存在这样的 $(l, r)$ ，则输出-1。

$\leq l \leq i \leq r \leq N$
$r - l + 1$ 是奇数。
$P$ 的连续子序列 $(P_l,P_{l+1},\dots,P_r)$ 的中位数不是 $P_i$ 。

这里，长度为 $L$ （奇数）的整数序列 $A$ 的中位数定义为将 $A$ 按升序排序后得到的序列 $A^{'}$ 的 $\frac{L+1}{2}$ /之值。

分析：

我们假设 $ans_i$ 表示 $i$ 位置的答案，因为 $p$ 是一个排列，同时区间长度为奇数，所以有且仅有一个位置是该区间的中位数。所以满足 $ans_i > k$ 的 $i$ 的个数不超过 $\lceil \frac{n}{k} \rceil$ 。考虑从小到大枚举区间长度 $k$ ，每次对还未确定答案的位置判断是否存在长度为 $k$ 的合法区间。用 $1$ 表示大于 $p_i$ 的元素， $- 1$ 表示小于 $p_i$ 的元素， $0$ 表示 $p_i$ ，为了使得 $p_i$ 成为中位数，区间内的和要为 $0$ 。通过找规律发现，假定 $i$ 左右两侧都有足够多的元素，那么对任意奇数 $k$ 仅有两种情况能够满足 $ans_i > k$ 。所以每次判断只需要在前面的基础上判断常数种情况即可。上述规律不包括边界 $1$ 和 $n$ ，所以要对 $1$ 和 $n$ 单独进行处理。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 5e5 + 5;
LL n, a[N], sum[N], i, k;
vector<LL> tmp1, tmp2;

int main() {
    cin >> n;
    for (i = 1; i <= n; i++)
        cin >> a[i];
    for (i = 1; i <= n; i++) {
        if (i > 2 && ((a[i - 2] < a[i]) == (a[i - 1] < a[i])))
            sum[i] = 3;
        else if (i > 1 && i < n && ((a[i - 1] < a[i]) == (a[i + 1] < a[i])))
            sum[i] = 3;
        else if (i < n - 1 && ((a[i + 1] < a[i]) == (a[i + 2] < a[i])))
            sum[i] = 3;
        else
            tmp2.push_back(i);
    }
    for (k = 5; k <= n; k += 2) {
        tmp1 = tmp2;
        tmp2.clear();
        for (auto i: tmp1) {
            if (i - k + 2 > 0 && i < n && (a[i - k + 2] < a[i]) != (a[i - 1] < a[i]))
                sum[i] = k;
            else if (i - k + 1 > 0 && (a[i - k + 1] < a[i]) == (a[i - k + 2] < a[i]))
                sum[i] = k;
            else if (i + k - 2 <= n && i > 1 && (a[i + k - 2] < a[i]) != (a[i + 1] < a[i]))
                sum[i] = k;
            else if (i + k - 1 <= n && (a[i + k - 1] < a[i]) == (a[i + k - 2] < a[i]))
                sum[i] = k;
            else
                tmp2.push_back(i);
        }
    }
    for (auto i: tmp2)
        sum[i] = -1;
    for (i = 1; i <= n; i++)
        cout << sum[i] << ' ';
    return 0;
}

D.Bracket Walk （图论）

题意：

给你一个有向图 $G$ ，其中有 $N$ 个顶点和 $M$ 条边。顶点的编号从 $1$ 到 $N$ ，每条边都标有 ( 或 )。第 $i$ 条边是从顶点 $u_i$ 指向顶点 $v_i$ ，标签为 $c_i$ 。该图不包含多条边或自循环。

在这个图中，对于任意两个顶点 $s$ 和 $t$ ，都有一条从 $s$ 到 $t$ 的路径。

请判断在图 $G$ 中是否存在满足以下所有条件的路径：

路径的起点和终点顶点相同。
对于 $i=1,2,\dots,M$ ， $i$ 条边在路径过程中至少使用了一次。
将路径中使用的边的标签按照使用顺序排列得到的字符串是一个正则括号序列。

正则括号序列是满足以下条件之一的字符串：

空字符串。
它是由(正则括号序列 $A$ 和)依次连接得到的字符串。
是由两个非空的正则括号序列 $A$ 和 $B$ 依次连接得到的字符串。

分析：

如果存在一条 ( 与 ) 出现次数相等的路径，那么必然可以通过更换路径起点来将形成的字符串循环移位为一个合法括号序列。因此答案路径是否存在等同于这样的路径是否存在。
有向图中的一条回路可以视作若干个环的组合。想要构造一条符合要求回路，我们可以先对于每条边求出一个包含它的环，再通过多次经过或增加某个环来平衡 ( 与 ) 的数量。
令 ( 的出现次数严格大于 ) 的出现次数的环为 $A$ 类环，) 的出现次数严格大于 ( 的出现次数的环为 $B$ 类环。不难发现若 $A$ ， $B$ 类环同时存在，一定可以通过调整两种环的经过次数构造出一组合法解。
如果只出现一种环，那么合法解一定不存在。通过反证法证明：
假设存在一组合法解，取一个 $A$ 类环 $t m p$ ，由于合法解中每条边至少出现一次，我们将 $t m p$ 中的边从合法解中删除（若某条边出现多次则只删除一次），合法解中剩下的部分一定由若干环组成，且由于合法解中 ( 与 ) 出现次数相等，去掉 $t m p$ 后 ) 的出现次数必然多于 (。结合其由若干环组成，推断出这些环中至少存在一个 $B$ 类环，与前提矛盾。
而如果两种环均未出现，可以任意构造合法解。
综上，只需要分别求出途中是否存在 $A$ 和 $B$ 类环。令( 边的边权为 $- 1$ ，) 边的边权为 $1$ ，通过 $b e ll man - f or d$ 求负环即可。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 5010;
const int M = 2 * N;
struct Edge {
    int x, y;
    char c;
} edge[M];
int f[N], g[N], save1[N];
int n, m;

int solve(char c) {
    memset(f, 0, sizeof f);
    for (int t = 1; t <= n; t++) {
        memcpy(g, f, sizeof g);
        for (int j = 1; j <= m; j++)
            g[edge[j].y] = min(g[edge[j].y], g[edge[j].x] + ((edge[j].c == c) ? -1 : 1));
        swap(f, g);
    }
    for (int i = 1; i <= n; i++)
        save1[i] = f[i];
    for (int t = 1; t <= n; t++) {
        memcpy(g, f, sizeof g);
        for (int j = 1; j <= m; j++)
            g[edge[j].y] = min(g[edge[j].y], g[edge[j].x] + ((edge[j].c == c) ? -1 : 1));
        swap(f, g);
    }
    for (int i = 1; i <= n; i++)
        if (save1[i] != f[i])
            return true;
    return false;
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
        cin >> edge[i].x >> edge[i].y >> edge[i].c;
    int f1 = solve('('), f2 = solve(')');
    if (f1 ^ f2)
        cout << "No" << endl;
    else
        cout << "Yes" << endl;
    return 0;
}