2016 ACM/ICPC Asia Regional Qingdao Online

最新推荐文章于 2017-07-31 09:22:56 发布
最新推荐文章于 2017-07-31 09:22:56 发布
阅读量337 收藏
点赞数
分类专栏： Contest
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenzhenyu123456/article/details/52713337
版权

天天不知道忙些什么，先把代码留作 回忆(ˇˍˇ) 想～

A
题意：问你 >=n 的最小的 x ，使得x=2a∗3b∗4c∗5d其中 a、b、c、d>=0
思路：先预处理统计一下，然后每次二分查询。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e4 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
LL A[300000 + 10];
int top;
LL f[4][40];
const int N = 1e9;
int main()
{
    f[0][0] = 1;
    for(int i = 1; i <= 30; i++) {
        f[0][i] = f[0][i - 1] * 2;
    }

    f[1][0] = 1;
    for(int i = 1; i <= 18; i++) {
        f[1][i] = f[1][i - 1] * 3;
    }

    f[2][0] = 1;
    for(int i = 1; i <= 12; i++) {
        f[2][i] = f[2][i - 1] * 5;
    }

    f[3][0] = 1;
    for(int i = 1; i <= 10; i++) {
        f[3][i] = f[3][i - 1] * 7;
    }

    top = 0;
    for(int a = 0; a <= 30; a++) {
        LL ans = f[0][a];
        if(ans > N) break;

        for(int b = 0; b <= 18; b++) {
            if(ans * f[1][b] > N) break;
            ans *= f[1][b];

            for(int c = 0; c <= 12; c++) {
                if(ans * f[2][c] > N) break;
                ans *= f[2][c];

                for(int d = 0; d <= 10; d++) {
                    if(ans * f[3][d] > N) break;
                    ans *= f[3][d];
                    A[top++] = ans;
                    ans /= f[3][d];
                }
                ans /= f[2][c];
            }
            ans /= f[1][b];
        }
        ans /= f[0][a];
    }
    sort(A, A + top);
    int t; scanf("%d", &t);
    while(t--) {
        int n; scanf("%d", &n);
        int pos = lower_bound(A, A + top, n) - A;
        printf("%lld\n", A[pos]);
    }
    return 0;
}

B
题意：问你 ∑ni=11i 。
思路： n 足够大时 是可以取极值的。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e6 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
double ans[MAXN];
char str[MAXN];
int main()
{
    double sum = 0;
    for(int i = 1; i <= 1000000; i++) {
        sum = sum + 1.0 / i / i;
        ans[i] = sum;
    }
    while(scanf("%s", str) != EOF) {
        int len = strlen(str);
        if(len >= 7) {
            printf("%.5lf\n", ans[1000000]);
        }
        else {
            int n = 0;
            for(int i = 0; i < len; i++) {
                n = n * 10 + (str[i] - '0');
            }
            printf("%.5lf\n", ans[n]);
        }
    }
    return 0;
}

D

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
int main()
{
    LL L, R;
    while(scanf("%lld%lld", &L, &R) != EOF) {
        if(R <= 1) {
            printf("0\n");
        }
        else if(R <= 2) {
            printf("1\n");
        }
        else {
            printf("%lld\n", max((R - max(1LL, L) - 2) / 2 + 2, 2LL));
        }
    }
    return 0;
}

E

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
int main()
{
    int t; scanf("%d", &t);
    while(t--) {
        int n; scanf("%d", &n);
        printf(n & 1 ? "Balanced\n" : "Bad\n");
    }
    return 0;
}

F
题意：每个点的价值是Xi，让你找到一个欧拉路径使得路径上所经过的 X 值异或之和最大。

思路：首先存在欧拉路径的话，那么只有两种情况。
如果存在欧拉回路的话枚举起点即可，其他情况路径则是唯一的。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
int f[MAXN];
int Find(int p) {
    int t, son = p;
    while(p != f[p]) { p = f[p]; }
    while(son != p) { t = f[son]; f[son] = p; son = t; }
    return p;
}
vector<int> G[MAXN];
int d[MAXN], a[MAXN];
void Merge(int x, int y) {
    int fx = Find(x);
    int fy = Find(y);
    if(fx != fy) f[fx] = fy;
}
int main()
{
    int t; scanf("%d", &t);
    while(t--) {
        int n, m; scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            G[i].clear();
            f[i] = i; d[i] = 0;
        }
        while(m--) {
            int u, v; scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
            d[u]++; d[v]++;
            Merge(u, v);
        }
        int cnt = 0;
        for(int i = 1; i <= n; i++) {
            if(f[i] == i) {
                cnt++;
            }
        }
        if(cnt > 1) {
            printf("Impossible\n");
            continue;
        }
        cnt = 0; int u, v; u = v = -1;
        for(int i = 1; i <= n; i++) {
            if(d[i] & 1) {
                cnt++;
                if(u == -1) {
                    u = i;
                }
                else if(v == -1) {
                    v = i;
                }
            }
        }
        if(cnt == 0 || cnt == 2) {
            int ans = 0;
            for(int i = 1; i <= n; i++) {
                d[i] /= 2;
                if(d[i] > 0 && (d[i] & 1)) {
                    ans ^= a[i];
                }
            }
            if(cnt == 2) {
                ans ^= a[u]; ans ^= a[v];
            }
            else {
                int res = ans;
                ans = (res ^ a[1]);
                for(int i = 2; i <= n; i++) {
                    ans = max(ans, res ^ a[i]);
                }
            }
            printf("%d\n", ans);
        }
        else {
            printf("Impossible\n");
            continue;
        }
    }
    return 0;
}

G
题意：给定N个序列，每次合并序列的代价就是所合并序列的元素之和，你需要把 N 个序列合并成一个序列。现在给定一个花费T，让你找到一个最小的 k 使得每次合并不超过k的前提下花费 <=T <script type="math/tex" id="MathJax-Element-14"><= T</script>。
思路：二分，然后用两个队列去维护。最后一次合并 k 个是最优的，那么需要先求出第一次合并的序列个数x，然后每次合并 k <script type="math/tex" id="MathJax-Element-17">k</script>个。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
int n;
LL m, a[MAXN];
LL Work(int k) {
    queue<LL> X, Y; LL ans = 0;
    int d = (n - 1) % (k - 1);
    if(d != 0) {
        for(int i = 1; i <= d + 1; i++) {
            ans += a[i];
        }
        X.push(ans);
        for(int i = d + 2; i <= n; i++) {
            Y.push(a[i]);
        }
    }
    else {
        for(int i = 1; i <= n; i++) {
            Y.push(a[i]);
        }
    }
    while(X.size() + Y.size() > k) {
        LL res = 0;
        for(int i = 1; i <= k; i++) {
            if(!X.empty() && !Y.empty()) {
                if(X.front() > Y.front()) {
                    res += Y.front(); Y.pop();
                }
                else {
                    res += X.front(); X.pop();
                }
            }
            else if(!X.empty()) {
                res += X.front(); X.pop();
            }
            else if(!Y.empty()) {
                res += Y.front(); Y.pop();
            }
        }
        X.push(res); ans += res;
    }
    while(!X.empty()) {
        ans += X.front(); X.pop();
    }
    while(!Y.empty()) {
        ans += Y.front(); Y.pop();
    }
    return ans;
}
int main()
{
    int t; scanf("%d", &t);
    while(t--) {
        scanf("%d%lld", &n, &m);
        for(int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
        }
        sort(a + 1, a + n + 1);
        //printf("%lld\n", Work(3));
        int l = 2, r = n, ans;
        while(r >= l) {
            int mid = l + r >> 1;
            if(Work(mid) <= m) {
                ans = mid;
                r = mid - 1;
            }
            else {
                l = mid + 1;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

K
裸的最短路 + 最小割

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 1e4 + 10;
const int INF = 1e9 + 10;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
struct Map1 {
    struct Edge {
        int from, to, cap, flow, next;
    };
    Edge edge[MAXN * 4];
    int head[MAXN], edgenum, cur[MAXN];
    void init() { CLR(head, -1); edgenum = 0; }
    void addEdge(int u, int v, int w) {
        Edge E1 = {u, v, w, 0, head[u]};
        edge[edgenum] = E1;
        head[u] = edgenum++;
        Edge E2 = {v, u, -w, 0, head[v]};
        edge[edgenum] = E2;
        head[v] = edgenum++;
    }
    bool vis[MAXN]; int dist[MAXN];
    bool BFS(int s, int t) {
        queue<int> Q; CLR(dist, -1); CLR(vis, false); Q.push(s);
        vis[s] = true; dist[s] = 0;
        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            for(int i = head[u]; i != -1; i = edge[i].next) {
                Edge E = edge[i];
                if(!vis[E.to] && E.cap > E.flow) {
                    dist[E.to] = dist[u] + 1;
                    if(E.to == t) return true;
                    Q.push(E.to); vis[E.to] = true;
                }
            }
        }
        return false;
    }
    int DFS(int x, int a, int t) {
        if(x == t || a == 0) return a;
        int flow = 0, f;
        for(int &i = cur[x]; i != -1; i = edge[i].next) {
            Edge &E = edge[i];
            if(dist[E.to] == dist[x] + 1 && (f = DFS(E.to, min(E.cap - E.flow, a), t)) > 0) {
                edge[i].flow += f;
                edge[i^1].flow -= f;
                flow += f; a -= f;
                if(a == 0) break;
            }
        }
        return flow;
    }
    int Maxflow(int s, int t) {
        int flow = 0;
        while(BFS(s, t)) {
            memcpy(cur, head, sizeof(head));
            flow += DFS(s, INF, t);
        }
        return flow;
    }
};
Map1 dinic;
struct Map2 {
    struct Edge {
        int from, to, val, wood, next;
    };
    Edge edge[MAXN * 4];
    int head[MAXN], edgenum;
    void init() { CLR(head, -1); edgenum = 0; }
    void addEdge(int u, int v, int w1, int w2) {
        Edge E1 = {u, v, w1, w2, head[u]};
        edge[edgenum] = E1;
        head[u] = edgenum++;
        Edge E2 = {v, u, w1, w2, head[v]};
        edge[edgenum] = E2;
        head[v] = edgenum++;
    }
    bool vis[MAXN]; int dist[MAXN];
    void BFS(int s, int t) {
        CLR(vis, false); CLR(dist, INF);
        queue<int> Q; Q.push(s); vis[s] = true; dist[s] = 0;
        while(!Q.empty()) {
            int u = Q.front(); Q.pop(); vis[u] = false;
            for(int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if(dist[v] > dist[u] + edge[i].val) {
                    dist[v] = dist[u] + edge[i].val;
                    if(!vis[v]) {
                        vis[v] = true; Q.push(v);
                    }
                }
            }
        }
    }
};
Map2 SPFA;
int main()
{
    int t; scanf("%d", &t);
    while(t--) {
        int n, m; scanf("%d%d", &n, &m); SPFA.init();
        while(m--) {
            int u, v, w; scanf("%d%d%d", &u, &v, &w);
            SPFA.addEdge(u, v, 1, w);
        }
        SPFA.BFS(1, n); dinic.init();
        for(int i = 1; i <= n; i++) {
            for(int j = SPFA.head[i]; j != -1; j = SPFA.edge[j].next) {
                int v = SPFA.edge[j].to;
                if(SPFA.dist[i] + 1 == SPFA.dist[v]) {
                    dinic.addEdge(i, v, SPFA.edge[j].wood);
                }
            }
        }
        printf("%d\n", dinic.Maxflow(1, n));
    }
    return 0;
}
笑着走完自己的路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
The 36th ACM/ICPC Asia Regional Shanghai Site —— Online Contest
09-10
The 36th ACM/ICPC Asia Regional Shanghai Site —— Online Contest Problem Set
2016 ACM/ICPC Asia Regional Qingdao Online -Cure
小明的博客
04-16 2564
Problem Description Given an integer n, we only want to know the sum of 1/k2where kfrom 1to n. Input There are multiple cases.For each test case, there is a single line, containing a single positiv
2016 ACM/ICPC Asia Regional Qingdao Online 青岛赛区（已完成8题）
qq_33901573的博客
09-17 252
1001 <pre name="code" class="cpp">#include <iostream> #include <cstdio> #define min(a,b) ((a)<(b)?(a):(b)) #define min4(a,b,c,d) min(min(a,b),min(c,d)) using namespac...
2016 ACM/ICPC Asia Regional Qingdao Online 青岛区域赛部分题解
Collider
09-18 971
1001－I Count Two Three预处理所有型如2^a 3^b 5^c 7^d的数字即可，在1e9的数据范围内共有5194个，且1e9正好为最后一个2^a 3^b 5^c 7^d数，排序后二分查找即可。#include <cstdio> #include <cmath> #include <algorithm>using namespace std;const int inf = 1e9;
2016 ACM/ICPC Asia Regional Qingdao Online 1005
Tworld
09-17 980
题目大意：给出一个数字n，判断若有一种游戏有n种角色，该游戏是否有可能是平衡的，所谓平衡的就是指对于每种角色，赢和输的概率都为50% 解题思路：若n为2，则只能是A胜B或者B胜A，每一种角色输或赢的概率都为1，因此不符合条件； 若n为3，比如石头剪刀布，每一种角色都可以赢一种角色（如石头赢剪刀），也有可能输给一种角色（石头输给布），因此输赢均为50%，符合条件； 若n为5， 如图，可以
The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest
09-03
The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest 注意，解压密码是：3.1415926535897932384
ACM／ICPC的教学与实践
01-25
ACM／ICPC的教学与实践
PowerOJ 是 ACM/ICPC 或 OI 的在线评委
最新发布
03-08
Online Judge 的存在为 ACM/ICPC（国际大学生程序设计竞赛）和 OI（信息学奥林匹克竞赛）等比赛提供了便利，使得参赛选手可以在线提交代码进行评测，节省了大量的时间和人力成本。同时，Online Judge 也为广大程序员...
THE 30th ACM/ICPC ASIA REGIONAL 2005 HANGZHOU SITE
07-26
THE 30th ACM/ICPC ASIA REGIONAL 2005 HANGZHOU SITE Onsite Contest Session 8:30am – 13:30pm, November 20th 2005 (GMT+8) <br>知道是什么了吧。。。
2016 ACM/ICPC Asia Regional Qingdao Online(青岛网络赛)
Sizaif's 小屋
07-31 611
部分题解(A,B,E,F) A 先打表,后二分查找; #include #include #include #include #include #include #include using namespace std; const int INF=1000000; typedef long long ll; ll a[100010]; ll pow(ll
2016 ACM/ICPC Asia Regional Qingdao Online hdu 5884 Sort （二分+优先队列）★
Ezereal的博客
09-17 452
题意： 给定n个序列，以及他们的长度，问在总花费不超过T，每次合并的序列个数不多于k的情况下，k的最小值，合并的代价是合并序列的总长度和。 题解： 二分k，再用优先队列取出前k个小的，模拟下去，不过这样会T。由于ai小于1000，所以可以记录这1000个数出现的次数，将出现的数字压入队列，每次出队的时候判断一下就不T了。不过还有一个问题，比如长度为6的序列，每次取前3个，最后一次只会取最后两
2016 ACM/ICPC Asia Regional Qingdao Online比赛笔记
你那么爱笑，家里人知道吗？
09-18 590
I Count Two Three Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3582    Accepted Submission(s): 1094 Problem Description I will s
【2016 ACM/ICPC Asia Regional Qingdao Online】
dingguayi7025的博客
09-18 138
[ HDU 5878 ]I Count Two Three 考虑极端，1e9就是2的30次方，3的17次方，5的12次方，7的10次方。 而且，不超过1e9的乘积不过5000多个，于是预处理出来，然后每次二分找就可以了。 1 /* 2 TASK:I Count Two Three 2^a*3^b*5^c*7^d的最小的大于等于n的数是多少 3 LANG:C++ ...
第六届福建省大学生程序设计竞赛
世界很大
12-27 1356
弱就做出5道题。 A题： B题： C题： D题：
2016 百度之星 初赛A
世界很大
05-21 1254
A：hdoj 5690 All X 打个表看了看，发现循环最大不超过k，因为k最大为10000，就先暴力找一下，最多找k次。我们边找边记录结果，若发现相同的就说明找到一个循环节，直接跳出即可。 AC代码：#include <cstdio> #include <cstring> #include <cmath> #include <map> #include <set> #include <ios
2016年中国大学生程序设计竞赛（合肥）-重现赛
世界很大
11-09 1193
A 充要条件： 如果uuu 可以到达vv v点，那么一定有一条uuu 直达 vvv的有向边。 预处理闭包，然后checkcheckcheck一下就好。 #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;vector&gt; #include &lt;algorith...
第十一届“蓝狐网络杯”湖南省大学生计算机程序设计竞赛
世界很大
01-26 1170
后来才知道K题正式赛时没人AC，应该去做I题的。 o(╯□╰)o A题链接：A 没敢看。。。感觉是神题。 B题链接：B 处理出整数部分和小数部分，比较下就好了。 AC代码： #include #include #include #include #include #include #include #include #incl
第四场选拔赛
世界很大
04-09 916
A 思路：其实这里用了树的直径的性质：把一棵树砍两半，最远点对一定是这两棵新树里面的最远点对之间的一组组合。 这样预处理LCALCALCA，然后线段树维护即可。 参考代码： #include &lt;bits/stdc++.h&gt; #define ll o&lt;&lt;1 #define rr o&lt;&lt;1|1 using namespace std; typedef lon...
ACM/ICPC词汇
09-23
ACM/ICPC词汇是指与ACM竞赛和ICPC竞赛相关的术语和缩写。其中包括ICPC（国际大学生程序设计竞赛）、CF（Codeforces，是大多数人所熟知的ACM竞赛）、WF（全球总决赛，一般会联合ICPC讨论，即ICPC-WF）和CCPC（中国...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值