Codeforces Round #375 (Div. 2) ABCDEF题解

最新推荐文章于 2023-03-16 20:21:15 发布
最新推荐文章于 2023-03-16 20:21:15 发布
阅读量825 收藏
点赞数
分类专栏： 解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Noooooorth/article/details/52833558
版权

A. The New Year: Meeting Friends

同一直线上的三个人要集合，求三个人一共走的距离的最小值。

max(a, b, c) - min(a, b, c)

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 5e4 + 50;
const int MAXM = 1e4 + 50;

int a, b, c;

int main() {
#ifdef LOCAL_NORTH
//    FIN;
#endif // LOCAL_NORTH
    while (~scanf("%d%d%d", &a, &b, &c)) {
        printf("%d\n", max(a, max(b, c)) - min(a, min(b, c)));
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}

B. Text Document Analysis

输出括号外的单词的最大长度已经括号内单词的个数。

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 5e4 + 50;
const int MAXM = 1e4 + 50;

int n;
string s;

int main() {
#ifdef LOCAL_NORTH
    FIN;
#endif // LOCAL_NORTH
    while (cin >> n >> s) {
        int ans1 = 0, ans2 = 0, len = 0, in = 0;
        for (int i = 0; i < n; i++) {
            if (isalpha(s[i])) len++;
            else {
                if (!in) ans1 = max(ans1, len);
                else if (len) ans2++;
                len = 0;
                if (s[i] == '(' || s[i] == ')') in = 1 - in;
            }
        }
        ans1 = max(ans1, len);
        printf("%d %d\n", ans1, ans2);
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}

C. Polycarp at the Radio

有n首曲子明天要演奏，一个人希望他喜欢的m个乐队演奏的歌曲数的最大值最小。输出改变次数最少的演奏安排。

目的是使m个乐队至少演奏n/m首。

统计一下原来这m个乐队演奏的数目并排序。目的是使原本歌曲数多的演奏n/m+1首或n/m首（根据原本的次数判断一下改变后按演奏多少），原本少的演奏n/m首。这样一来，改变的次数就必定最小。

计算出为符合要求，乐队i需要增加或减少的歌曲数op[i]。这时op数组有正有负，来一次n^2的操作把所有的负数消掉，即找到op[i] < 0，op[j] > 0，然后op[i]++，op[j]--。

最后遍历整个序列，把大于m的乐队变为小于等于m的乐队。

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 2e3 + 50;
const int MAXM = 1e4 + 50;

int m, n, a[MAXN], op[MAXN], c[MAXN];
struct node{
    int c, id;
    node(int _c, int _id) {c = _c; id = _id;}
    bool operator < (const node& _) const {return c > _.c;}
};

int main() {
#ifdef LOCAL_NORTH
    FIN;
#endif // LOCAL_NORTH
    while (~scanf("%d%d", &n, &m)) {
        memset(c, 0, sizeof(c));
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            if (a[i] >= 1 && a[i] <= m) c[a[i]]++;
        }
        vector<node> v;
        for (int i = 1; i <= m; i++) v.pb(node(c[i], i));
        sort(v.begin(), v.end());
        int ans1 = n / m, ans2 = 0;
//        for (int i = 0; i < m; i++) printf("[%d]%c", v[i].c, " \n"[i == m - 1]);
        int fck = n % m;
        for (int i = 0; i < m; i++) {
            int id = v[i].id;
            op[id] = n / m - c[id];
            while (fck && op[id] <= -1) {
                op[id]++;
                fck--;
            }
            ans2 += abs(op[id]);
        }
//        for (int i = 1; i <= m; i++) printf("%d%c", op[i], " \n"[i == m]);
        for (int i = 1; i <= m; i++) {
            while (op[i] < 0) {
                int s = -1;
                for (int j = 1; j <= m; j++) {
                    if (op[j] > 0) {
                        s = j;
                        break;
                    }
                }
                for (int j = 1; j <= n; j++) {
                    if (a[j] == i) {
                        a[j] = s;
                        op[i]++;
                        op[s]--;
                        ans2--;
                        break;
                    }
                }
            }
        }
        printf("%d %d\n", ans1, ans2);
        for (int i = 1; i <= n; i++) {
            if (a[i] < 1 || a[i] > m) {
                for (int j = 1; j <= m; j++) {
                    if (op[j] > 0) {
                        op[j]--;
                        a[i] = j;
                        break;
                    }
                }
            }
            printf("%d%c", a[i], " \n"[i == n]);
        }
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}

D. Lakes in Berland

把最少的水地变为土地，使得湖（连通块）的数目等于k。

bfs一遍统计出湖的个数、每个湖的大小以及湖的任意一点。

排序后，从每个湖中的点开始，把前tot-k个湖变为土地。

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 100 + 50;
const int MAXM = 1e4 + 50;

int n, m, k, d[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
char p[MAXN][MAXN];
bool vis[MAXN][MAXN];
struct node{
    int x, y, c;
    bool operator < (const node& _) const {return c < _.c;}
}lakes[MAXN * MAXN];

int main() {
#ifdef LOCAL_NORTH
    FIN;
#endif // LOCAL_NORTH
    while (~scanf("%d%d%d", &n, &m, &k)) {
        memset(vis, false, sizeof(vis));
        for (int i = 1; i <= n; i++) scanf("%s", p[i] + 1);
        int tot = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (p[i][j] == '.' && !vis[i][j]) {
                    bool ok = true;
                    int cnt = 0;
                    queue<PII > q;
                    q.push(mp(i, j));
                    vis[i][j] = true;
                    while (!q.empty()) {
                        PII cur = q.front();
                        q.pop();
                        int x = cur.first, y = cur.second;
                        cnt++;
                        if (x < 1 || x > n || y < 1 || y > m) {
                            ok = false;
                            continue;
                        }
                        for (int l = 0; l < 4; l++) {
                            int xx = x + d[l][0], yy = y + d[l][1];
                            if (xx >= 0 && xx <= n + 1 && yy >= 0 && yy <= m + 1 && !vis[xx][yy] && p[xx][yy] != '*')
                                q.push(mp(xx, yy));
                                vis[xx][yy] = true;
                        }
                    }
                    if (ok) {
                        lakes[tot].c = cnt;
                        lakes[tot].x = i;
                        lakes[tot++].y = j;
                    }
                }
            }
        }
        sort(lakes, lakes + tot);
        int ans = 0;
        for (int i = 0; i < tot - k; i++) {
            ans += lakes[i].c;
            queue<PII > q;
            q.push(mp(lakes[i].x, lakes[i].y));
            p[lakes[i].x][lakes[i].y] = '*';
            while (!q.empty()) {
                PII cur = q.front();
                q.pop();
                int x = cur.first, y = cur.second;
                for (int j = 0; j < 4; j++) {
                    int xx = x + d[j][0], yy = y + d[j][1];
                    if (xx > 0 && xx <= n && yy > 0 && yy <= m && p[xx][yy] != '*') {
                        p[xx][yy] = '*';
                        q.push(mp(xx, yy));
                    }
                }
            }
        }
        printf("%d\n", ans);
        for (int i = 1; i <= n; i++) printf("%s\n", p[i] + 1);
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}

E. One-Way Reform

把无向图转化为有向图，同时使得出度等于入度的点最多。并打印边。

为了使出度等于入度的点最多，要把原图转化为欧拉图，操作为：原图中奇数度的点一定有偶数个，所有将度为奇数的点两两（不是点i与所有的奇数度点连边，而是点i与任意一奇数度点相连）之间加一条边。

然后用Fleury打印欧拉回路即可，注意添加的边不要打印。

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 50;
const int MAXM = 1e5 + 50;

int n, m, d[MAXN];
bool vis[MAXN];
struct Edge{
    int v, f, p, nxt;
} E[MAXM << 1];
int tot, Head[MAXN];
void edge_init() {
    tot = 0;
    memset(Head, -1, sizeof(Head));
}
void edge_add(int u, int v, int p) {
    E[tot].v = v; E[tot].f = 0; E[tot].p = p; E[tot].nxt = Head[u]; Head[u] = tot++;
    E[tot].v = u; E[tot].f = 0; E[tot].p = p; E[tot].nxt = Head[v]; Head[v] = tot++;
}

vector<int> odd;
void dfs(int u) {
    vis[u] = true;
    for (int i = Head[u]; ~i; i = E[i].nxt) {
        if (E[i | 1].f) continue;
        E[i | 1].f = 1;
        if (E[i].p) printf("%d %d\n", u, E[i].v);
        dfs(E[i].v);
//        return; !!!!
    }
}

int main() {
#ifdef LOCAL_NORTH
    FIN;
#endif // LOCAL_NORTH
    int T;
    scanf("%d", &T);
    while (T--) {
        memset(d, 0, sizeof(d));
        memset(vis, false, sizeof(vis));
        odd.clear();
        edge_init();
        scanf("%d%d", &n, &m);
        for (int i = 0; i < m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            edge_add(u, v, 1);
            d[u]++;
            d[v]++;
        }
        int ans = 0;
        for (int i = 1; i <= n; i++)
            if (d[i] & 1) odd.pb(i);
            else ans++;
        for (int i = 0, sz = odd.size(); i < sz - 1; i += 2)
            edge_add(odd[i], odd[i + 1], 0);
        printf("%d\n", ans);
        for (int i = 1; i <= n; i++)
            if (!vis[i])
                dfs(i);
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}

F. st-Spanning Tree

在原图的基础上构建一棵生成树，同时s的度不大于ds，t的度不大于dt，并打印边。

为了使和s、t相连的边数最少，需要在去掉s和t的每个连通分量内构建一棵生成树。

然后把所有生成树连到s和t上。需要注意不是随便连，否则会出现一个连通分量既可以连到s，也可以连到t，但最后连错导致s和t度数错误。一种可行的方法是每次遇到上文描述的情况，将生成树连到距离度数限制较大的点上。

经过上一步，原图已经变成了两棵生成树，同时注意到图中没有被选中用来构建生成树的边只有3种：

1）端点为s和t；2）一端为s，另一端不为t；3）一端为t，另一端不为s。

现在只需要在一棵生成树上找到任意一条连上后符合题意的边。

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
typedef pair<int,int> PII;
#define mp make_pair
#define pb push_back
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
#define lowbit(x) ((x)&(-(x)))
#define bitcnt(x) __builtin_popcount(x)
#define bitcntll(x) __builtin_popcountll(x)
#define debug puts("-------------");
//#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 50;
const int MAXM = 4e5 + 50;

int n, m, s, t, ds, dt;
struct Edge{
    int u, v;
}E[MAXM];

int par[MAXN];
int Find(int x) {return par[x] == x ? x : par[x] = Find(par[x]);}
void unite(int a, int b) {
    int x = Find(a), y = Find(b);
    if (x != y) par[x] = y;
}

vector<PII > ans;
bool link[MAXN][2];
int STlink[MAXN], dus, dut;
bool ST2S[MAXN], ST2T[MAXN];
void solveST() {
    for (int i = 0; i < m; i++) {
        int u = E[i].u, v = E[i].v;
        if (u == s || u == t || v == s || v == t)
            continue;
        if (Find(u) != Find(v)) {
            unite(u, v);
            ans.pb(mp(u, v));
        }
    }
    memset(ST2S, false, sizeof(ST2S));
    memset(ST2T, false, sizeof(ST2T));
    for (int i = 1; i <= n; i++) {
        if (i == s || i == t) continue;
        if (link[i][0])
            ST2S[Find(i)] = true;
        if (link[i][1])
            ST2T[Find(i)] = true;
    }
}
void linkST() {
    dus = dut = 0;
    memset(STlink, -1, sizeof(STlink));
    for (int i = 1; i <= n; i++) {
        if (i == s || i == t) continue;
        int stNo = Find(i);
        if (STlink[stNo] != -1) continue;
        bool ok1 = (ST2S[stNo] && dus < ds && link[i][0]);
        bool ok2 = (ST2T[stNo] && dut < dt && link[i][1]);
        int tmp = -1;
        if (ok1 && ok2) {
            if (ds - dus > dt - dut) tmp = s;
            else tmp = t;
        } else if (ok1) tmp = s;
        else if (ok2) tmp = t;
        if (tmp == s) {
            STlink[stNo] = 0;
            unite(i, s);
            ans.pb(mp(i, s));
            dus++;
        } else if (tmp == t) {
            STlink[stNo] = 1;
            unite(i, t);
            ans.pb(mp(i, t));
            dut++;
        }
    }
}
bool Link() {
    if (dus < ds && dut < dt && link[t][0]) {
        dut++, dus++;
        ans.pb(mp(s, t));
        unite(s, t);
        return true;
    }
    for (int i = 1; i <= n; i++) {
        if (i == s || i == t) continue;
        if (Find(i) == Find(s)) {
            if (dut < dt && link[i][1]) {
                dut++;
                ans.pb(mp(t, i));
                unite(i, t);
                return true;
            }
        } else if (Find(i) == Find(t)) {
            if (dus < ds && link[i][0]) {
                dus++;
                ans.pb(mp(s, i));
                unite(i, s);
                return true;
            }
        }
    }
    return false;
}

int main() {
#ifdef LOCAL_NORTH
    FIN;
#endif // LOCAL_NORTH
    while (~scanf("%d%d", &n, &m)) {
        ans.clear();
        memset(link, false, sizeof(link)); //link[i][0]表示是i否与s相连，link[i][1]表示i是否与t相连。
        for (int i = 1; i <= n; i++) par[i] = i;
        for (int i = 0; i < m; i++)
            scanf("%d%d", &E[i].u, &E[i].v);
        scanf("%d%d%d%d", &s, &t, &ds, &dt);
        for (int i = 0; i < m; i++) {
            if (E[i].u == s || E[i].v == s)
                link[E[i].u + E[i].v - s][0] = true;
            if (E[i].u == t || E[i].v == t)
                link[E[i].u + E[i].v - t][1] = true;
        }
        link[s][0] = link[t][1] = true;
        solveST(); //构建生成树
        linkST(); //生成树连向s和t
        if (dus > ds || dut > dt) {
            printf("No\n");
            continue;
        }
        bool ok = Link(); //两棵生成树相连
        for (int i = 1; i <= n; i++)
            ok &= (Find(i) == Find(1));
        if (!ok) {
            printf("No\n");
            continue;
        }
        if (dus <= ds && dut <= dt) {
            printf("Yes\n");
            int sz = ans.size();
            for (int i = 0; i < sz; i++)
                printf("%d %d\n", ans[i].first, ans[i].second);
        } else printf("No\n");
    }
#ifdef LOCAL_NORTH
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // LOCAL_NORTH
    return 0;
}


Noooooorth
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #375 (Div. 2) 题解
I good vegetable a!
10-12 286
【A】水题，把x1,x2,x3排序之后，答案就是x2-x1。 【B】水题，模拟一下就好。 【复杂度】O(len) 【代码君】 // //Created by just_sort 2016/10/3 18:45 //Copyright (c) 2016 just_sort.All Rights Reserved // #include #include #include #inc
Codeforces Round #375 (Div. 2)题解
qkhhsuhrtfk的博客
09-19 255
嗯，我又来写题解啦。 　　先放链接：div. 2 　　A. The New Year: Meeting friends　　可以证明在中位数的地方总距离最小，然后这道题只有3个数字，所以答案显然就是最大值减最小值。复杂度O(1)O(1)。#include<bits/stdc++.h> using namespace std; int main() { int a,b,c; scan
【解题报告】Codeforces Round #375 (Div. 2)
TRiddle的博客
10-05 570
简略的解题报告。
codeforces round375(div.2)题解
weixin_30363981的博客
10-06 61
首先吐槽一下这套题。。。为什么EF全是图论QAQ 过了ABCD四个题。。。F的并查集死磕了好久。。。 不过似乎rank还算乐观。。。（因为ABC都是一次过的QAQ） Problem A： 啥都不想说QAQ。。。 代码如下： 1 var a,b,c,d,max,min,ans:longint; 2 begin 3 readln(a,b,c); 4 max:=a;...
Codeforces Round #375 (Div. 2) 个人题解
teddywang
10-05 605
第一次参加Codeforces，这次算上终测一共过了4题，果然读英文题和中文题还是有很大差距的。 A. The New Year: Meeting Friends time limit per test 1 second memory limit per test 256 megabytes input standard input outp
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
【Codeforces Round#620 (Div. 2)】B. Longest Palindrome 题解
01-06
题目链接：B. Longest Palindrome 题目 Returning back to problem solving, Gildong is now studying about palindromes. He learned that a palindrome is a string that is the same as its reverse....
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
Codeforces Round #375 (Div. 2) 题目解析&总结
床前明月光
10-30 179
A题： 题目连接：http://codeforces.com/contest/723/problem/A 题意：三个人同时到某个位置，问移动距离总和最小是多少 思路：到中位数是最优的，详情查询“带权中位数”有证明 题解：https://blog.csdn.net/xiang_6/article/details/83549914   B题： 题目连接：http://codeforces...
网络流24题
量子流逝
10-21 1326
01 #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; #ifdef _WIN32 #define i64 __int64 #define out64 "%I64d\
C/C++，的0x3f3f3f3f与0xc0c0c0c0
最新发布
m0_67500944的博客
03-16 554
如果问题中各数据的范围明确，那么无穷大的设定不是问题，在不明确的情况下，很多程序员都取0x7fffffff作为无穷大，因为这是32-bit int的最大值。如果这个无穷大只用于一般的比较（比如求最小值时min变量的初值），那么0x7fffffff确实是一个完美的选择，但是在更多的情况下，0x7fffffff并不是一个好的选择。
无穷大inf = 0x3f3f3f3f
凌汐凡的博客
01-10 1096
inf = 0x3f3f3f3f inf = 0x3f3f3f3f在一般场合作为无穷大来使用，int类型真正的无穷大是 inf = 0x7fffffff（32_bit的最大值），它能够表示int的无穷大，但是当在它的基础上加上某个数的时候会变成负数。 准确的说：inf = 0x7fffffff不满足“无穷大加上一个无穷大仍然是无穷大” 所以我们引入 inf = 0x3f3f3f3f，它的准确值为10^9+,在一般场合下均可以作为一个无穷大使用，而inf+inf又不会超过int的范围，所以满足“无穷大加上一个
0x3f3f3f3f是什么意思？？？
热门推荐
qq_31267769的博客
03-29 3万+
ACM中常用的无穷大常量——0x3f3f3f3f 最近做题看题解的时候发现在大佬的题解报告中常会出现这么一行：↓↓↓ const int inf = 0x3f3f3f3f; 然后我就去探索了一下，0x3f3f3f3f的十进制是1061109567，是10^9级别的，而一般场合下的数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。 一般dfs或者dp求最小值......
背包问题总结
weixin_41934068的博客
07-28 111
1.01背包 01背包问题 #include <cstdio> #include <stack> #include <algorithm> #include <cstring> #include <cmath> #include <iostream> #include <map> #include <v...
AtCoder Beginner Contest 179----D.Leaping Tak
0k-ok
11-11 215
旧人旧事更值得怀念，或悲或喜每个人身上都承载着某一段时光，但是我会永远清澈永远疯狂永远浪漫。没有人能回到过去重新活过，但你我都可以从现在开始，决定我们未来的模样。 ---...
一般常量表示
Lancetop的博客
04-04 360
const int INF = 0x3f3f3f3f; const long long INF_LL = 0x3f3f3f3f3f3f3f3fLL; const int MOD = int(1e9 + 7); const long long MOD_LL = 1000000000000000007LL; const double EPS = 1e-9; const double PI = aco...
牛客每日练习----集合问题，小H和游戏，圆圆
0k-ok
08-13 306
我喜欢给自己压力，必须得定一个很高的目标，逼自己朝着这个目标前进，不管会不会实现，都是一个动力。 ----喻言 链接：https://ac.nowcoder.com/acm/problem/15167 来源：牛客网 题目描述 给你a,b和n个数p[i]，问你如何分配这n个数给A,B集合，并且满足： 若x在集合A中，则a-x必须也在集合A中。 若x在集合B中，则b-x必须也在集合B中。 输入描述: 第一行 三个数 n...
codeforces round #772 (div. 2)
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值