2013 icpc 长沙 (5.12)

最新推荐文章于 2018-05-28 17:30:27 发布
最新推荐文章于 2018-05-28 17:30:27 发布
阅读量205 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbltyyj/article/details/80483741
版权

A - Alice’s Print Service

题目链接 https://vjudge.net/contest/228708#problem/A

题解

签到题
二分
有个小坑点，要维护一个最小值的数组

#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

#define fi first
#define se second
#define fio ios::sync_with_stdio(false);cin.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;

const int INF = 0x3f3f3f3f;
const int M = 100005;
const int MOD = 1e9 + 7;
const double pi = acos(-1);

struct P
{
    int l, v;
    ll vv;
    bool operator < (const P& a) const
    {
        return l < a.l;
    }
}p[100005];
ll mm[100005];

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n, m;
        scanf("%d %d", &n, &m);
        for(int i = 0; i < n; ++i)
        {
            scanf("%d %d", &p[i].l, &p[i].v);
            p[i].vv = p[i].l * 1ll * p[i].v;
        }
        ll mi = p[n - 1].vv;
        for(int i = n - 1; i >= 0; --i)
        {
            if(mi > p[i].vv) mi = p[i].vv;
            mm[i] = mi;
        }
        for(int i = 0; i < m; ++i)
        {
            int x;
            ll ans = 0;
            scanf("%d", &x);
            if(x == 0)
            {
                puts("0");
                continue;
            }
            int t = upper_bound(p, p + n, P{x, 0, 0}) - p;
            if(t == n) ans = p[t - 1].v * 1ll * x;
            else ans = min(mm[t], p[t - 1].v * 1ll * x);
            printf("%lld\n", ans);
        }
    }
    return 0;
}

B - Bob’s new toy

题目链接 https://vjudge.net/contest/228708#problem/B

C - Collision

题目链接 https://vjudge.net/contest/228708#problem/C

D - Arnold

题目链接 https://vjudge.net/contest/228708#problem/D

题解

对于fib数列的最小循环节的求法，我们可以这样：
1、令n=p1^m1 * p2^m2 * p3^m3……
2、分别计算fib数列在模p1^m1,p2^m2……意义下的最小循环节
我们考虑如何计算p1^m1的循环节
这里有一个定理:G(p1^m1)=G(p1)*p1^(m-1)
我们只需要计算G(p)就可以了
f(n) = a * f(n - 1) + b * f(n - 2);
f(1) = c, f(2) = d // 可忽略
求f(n)mod p循环节长度
c = a * a + 4b
是模p的二次剩余时，枚举n = p - 1的因子
否则 枚举n=2*(p+1)的因子
3、模n意义下的最小循环节为2步骤各循环节的LCM

代码

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define fi first
#define se second
#define lson l,mid,o<<1
#define rson mid+1,r,o<<1|1
#define fio ios::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int, int> P;
typedef pair<P, int> PII;
typedef pair<LL, int> PIII;
const LL INF = 0x3f3f3f3f;
const int N = 1e6 + 10;
const int M = 3e6 + 10;
//const LL mod = 1e9 + 7;
const double PI=acos(-1);
inline LL ab(LL x){return x < 0 ? -x : x;}
inline LL mm(LL x, LL p){return x >= p ? x - p : x < 0 ? x + p : x;}


LL mod;
LL mul(LL x,LL y){
    LL res = 0;
    while(y){
        if(y & 1)   res = mm(res + x, mod);
        x = mm(x << 1, mod);
        y >>= 1;
    }
    return res;
}
LL gcd(LL x, LL y){
    return x ? gcd(y % x, x) : y;
}
LL lcm(LL x, LL y){
    return x / gcd(x, y) * y;
}
LL qpow(LL x, LL y){
    LL res = 1ll;
    x %= mod;
    while(y){
        if(y & 1)   res = mul(res , x);
        x = mul(x , x);
        y >>= 1;
    }
    return res;
}
/// 判断x是否是p的二次剩余;
bool legendre(LL x, LL p) {
    LL t = qpow(x, (p - 1) >> 1);
    if(t == 1ll) return true;
    return false;
}
struct Matrix{
    LL v[2][2];
    Matrix operator * (Matrix &it) const{
        Matrix res;
        memset(res.v, 0, sizeof res.v);
        for(int i = 0; i < 2; ++i)
            for(int j = 0; j < 2; ++j)
                for(int h = 0; h < 2; ++h)
                    res.v[i][j] = mm(res.v[i][j] + mul(v[i][h] , it.v[h][j]), mod);
        return res;
    }
}init_mat, mat;
Matrix qpow(Matrix now, LL y){
    Matrix res;
    res = init_mat;
    while(y){
        if(y & 1)   res = res * now;
        now = now * now;
        y >>= 1;
    }
    return res;
}
LL st[N], tot;
bool ok(Matrix &now){
    return ((now.v[0][0] + now.v[0][1]) % mod == 1ll && (now.v[1][0] + now.v[1][1]) % mod == 0ll);
}
LL get_loop(LL c, LL p){
    if(p==2)return 3;
    else if(p==3)return 8;
    else if(p==5)return 20;
    mod = p;
    if(legendre(c, p))  p = mod - 1;
    else    p = 2ll * (mod + 1);
    tot = 0;
    Matrix now;
    for(LL i = 1; i * i <= p; ++i){
        if(p % i == 0){
            now = qpow(mat, i-1);
            if(ok(now)) return i;
            if(i != p / i)  st[++tot] = p / i;
        }
    }
    while(tot){
        now = qpow(mat, st[tot]-1);
        if(ok(now)) return st[tot];
        tot--;
    }
    return 0;
}
LL solve(LL c, LL n){
    LL ans = 1, now;
    for(LL i = 2; i * i <= n; ++i){
        if(n % i == 0){
            now = 1;
            while(n % i == 0)   now *= i, n /= i;
            now /= i;
            now *= get_loop(c, i);
            ans = lcm(ans, now);
        }
    }
    if(n != 1){
        now = get_loop(c, n);
        ans = lcm(ans, now);
    }
    return ans;
}
int main()
{
    init_mat.v[0][0] = init_mat.v[1][1] = 1;
    mat.v[0][0] = 1, mat.v[0][1] = 1;
    mat.v[1][0] = 1, mat.v[1][1] = 0;
    LL n;
    while(~scanf("%lld", &n)){
        LL ans = solve(5ll, n);
        if(!(ans & 1)) ans >>= 1;
        printf("%lld\n", ans);
    }
    return 0;
}
/*
4461651651
231651213
216512121
1115132185
1165121213
216511562
216513213
1654234161
2165121651
156121561
165485165
21651
2621
15613
1365416
*/

E - Easy Problem Once More

题目链接 https://vjudge.net/contest/228708#problem/E

F - Winter’s Coming

题目链接 https://vjudge.net/contest/228708#problem/F

G - Graph Reconstruction

题目链接 https://vjudge.net/contest/228708#problem/G

题解

贪心的从度数最大的点开始建边,每次和剩下来的前k大建,然后就一直贪心下去就可以了.
多解的话考虑将存在两条边uv和u’v’, 那么把他换成uv’和u’v就可以了

代码

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define fi first
#define se second
#define lson l,mid,o<<1
#define rson mid+1,r,o<<1|1
#define fio ios::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int, int> P;
typedef pair<P, LL> PII;
typedef pair<LL, int> PIII;
const LL INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
const int M = 3e6 + 10;
const LL mod = 1e9 + 7;
const double PI=acos(-1);
inline LL ab(LL x){return x < 0 ? -x : x;}
inline LL mm(LL x, LL p){return x >= p ? x - p : x < 0 ? x + p : x;}

int v[200];
vector<P>ans;
priority_queue<P>que;
P lis[200];
int main()
{
    int n;
    while(~scanf("%d", &n)){
        for(int i = 1; i <= n; ++i) scanf("%d", &v[i]);
        ans.clear();
        while(!que.empty()) que.pop();
        P now;
        bool flag = true, mu = false;
        for(int i = 1; i <= n; ++i){
            if(v[i]) que.push({v[i], i});
        }
        while(!que.empty() && flag){
            now = que.top();    que.pop();
            for(int i = 1; i <= now.fi; ++i){
                if(que.empty()) flag = false;
                else{
                    lis[i] = que.top();que.pop();
                }
            }
            if(!mu && !que.empty()){
                mu = true;
            }
            for(int i = 1; i <= now.fi; ++i){
                ans.push_back({now.se, lis[i].se});
                if(lis[i].fi > 1)   que.push({lis[i].fi - 1, lis[i].se});
            }
        }
        if(!flag)   puts("IMPOSSIBLE");
        else{
            if(mu)  puts("MULTIPLE");
            else    puts("UNIQUE");
            printf("%d %d\n", n, ans.size());
            for(int i = 0; i < ans.size(); ++i){
                printf("%d ", ans[i].fi);
            }
            puts("");
            for(int i = 0; i < ans.size(); ++i){
                printf("%d ", ans[i].se);
            }
            puts("");
            if(mu){
                mu = false;
                ans.clear();
                for(int i = 1; i <= n; ++i) if(v[i]) que.push({v[i], i});
                while(!que.empty() && flag){
                    now = que.top();    que.pop();
                    for(int i = 1; i <= now.fi; ++i){
                        lis[i] = que.top();que.pop();
                    }
                    if(!mu && !que.empty()){
                        lis[0] = que.top();
                        mu = true;
                        que.pop();
                        que.push(lis[now.fi]);
                        lis[now.fi] = lis[0];
                    }
                    for(int i = 1; i <= now.fi; ++i){
                        ans.push_back({now.se, lis[i].se});
                        if(lis[i].fi > 1)   que.push({lis[i].fi - 1, lis[i].se});
                    }
                }
                printf("%d %d\n", n, ans.size());
                for(int i = 0; i < ans.size(); ++i){
                    printf("%d ", ans[i].fi);
                }
                puts("");
                for(int i = 0; i < ans.size(); ++i){
                    printf("%d ", ans[i].se);
                }
                puts("");
            }
        }
    }
    return 0;
}

H - Skycity

题目链接 https://vjudge.net/contest/228708#problem/H

I - LIKE vs CANDLE

题目链接 https://vjudge.net/contest/228708#problem/I

题解

树形dp, 0表示不翻, 1表示翻 然后xjb维护就可以了

代码

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define fi first
#define se second
#define lson l,mid,o<<1
#define rson mid+1,r,o<<1|1
#define fio ios::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int, int> P;
typedef pair<P, int> PII;
typedef pair<LL, int> PIII;
const LL INF = 0x3f3f3f3f;
const int N = 5e4 + 10;
const int M = 3e6 + 10;
const LL mod = 1e9 + 7;
const double PI=acos(-1);
inline LL ab(LL x){return x < 0 ? -x : x;}
inline LL mm(LL x, LL p){return x >= p ? x - p : x < 0 ? x + p : x;}

int n, x, y, flag;
vector<int>son[N];
struct Node{
    int op, v;
    int dp[2];
}node[N];


void dfs(int o){
    flag ^= node[o].op;
    if(flag)    node[o].v = -node[o].v;
    node[o].dp[0] = node[o].v, node[o].dp[1] = - node[o].v;
    for(auto it : son[o]){
        dfs(it);
        node[o].dp[0] += max(node[it].dp[0], node[it].dp[1] - (node[it].op ? y : x));
        node[o].dp[1] += max(node[it].dp[1], node[it].dp[0] - (node[it].op ? y : x));
    }
    flag ^= node[o].op;
}
int main()
{
    while(~scanf("%d%d%d",&n, &x, &y)){
        int v, f, s, p;
        flag = 0;
        for(int i = 0; i <= n; ++i) son[i].clear();
        for(int i = 1; i <= n; ++i){
            scanf("%d%d%d%d", &v, &f, &s, &p);
            node[i].op = s;
            if(p)   node[i].v = -v;
            else    node[i].v = v;
            son[f].push_back(i);
        }
        dfs(0);
        if(node[0].dp[0] < 0) puts("HAHAHAOMG");
        else    printf("%d\n", node[0].dp[0]);
    }
    return 0;
}

J - Josephina and RPG

题目链接 https://vjudge.net/contest/228708#problem/J

K - Pocket Cube

题目链接 https://vjudge.net/contest/228708#problem/K

lbltyyj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
icpc2013长沙区域赛
m0_49959202的博客
12-22 171
文章目录icpc2013长沙区域赛A.Alice's Print ServiceC.CollisionG.Graph ReconstructionH.SkycityI.LIKE vs CANDLEJ.Josephina and RPGK.Pocket Cube icpc2013长沙区域赛 A.Alice’s Print Service 题意： 现在你要打印一些东西，比如需要99张纸，打印100张以下时话费10元每张，100张及100张以上时需要5元每张，此时你可以选择打印100张，使得花费更小。现给一个数字
ICPC 2013 长沙赛区
weixin_30813225的博客
11-23 124
G - Graph Reconstruction可图判定问题 　　首先应用Havel-hakimi定理判定该度数序列是否可图，队友A掉这道题以后，我学习了一下Havel-hakimi定理，下面简单介绍并且证明一下。 　　定理应用场景：给出节点的度数序列，判断该序列是否为一个具体图或者简单图的度数序列（与此题背景相符合） 　　过程描述：对序列进行度数从大到小排序，每次把第一个节点的度数设...
2013 ACM-ICPC 长沙赛区 部分分析
lost@hdu
12-12 1380
A hdu 4791  Alice's Print Service 需要在纸上计算发现一个事实，只会取一种价格的纸。 然后就很容易编码了，注意爆32位的细节。 /* author:ray007great version:1.0 */ #include #include #include #include #include #include #include #includ
2013 ACM-ICPC长沙赛区全国邀请赛——Travel in time
Confidence的专栏
05-08 1468
给n个点，m条边的无向图，一个起点和一个终点。每边都有消耗，经过就要付出代价；每个点有消耗和价值，只有消耗了才会获得价值，如果不消耗就不会获得价值，且下一次消耗的点的价值一定要严格大于之前消耗过的点的价值 求：起点到终点消耗不超过给定值T时的价值最大值 1 < N < 100，0 < M < 1000，0 < T <= 300
2013 ACM/ICPC 长沙赛区现场赛A题 解题报告
ACM小菜鸟silence的博客
11-24 2424
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3726 题意容易理解：就是一个打印分段收费政策，印的越多，单张价格越低，输入需要印刷的数量，求最小印刷费用 思路：由于印的张数越多，单价越便宜 可以对数据进行预处理： 先求每一种价格对应的最小费用，也就是张数刚刚好时的费用，最小费用sp=s[i]*p[i
ICPC2013 WF 试题
07-03
ICPC2013 WF 试题， pdf格式
2023河南ICPC题
09-16
环数的个数，对 998244353 取模。...Page 2 of 16河南省第十四届 ICPC 大学生程序设计竞赛The 2023 ICPC China Henan Provincial Programming Contest2023/05/21Problem C. 结对编程Input file:standard
2013 ACM ICPC Southeast USA Regional Programming Contest
03-16
2013 ACM ICPC Southeast USA Regional Programming Contest 原题
icpc2019.pdf
04-03
icpc 基础，推荐一下！
文章标题 HDU 5584：LCM Walk（数学推导）
Wang_SF2015的博客
08-09 305
LCM WalkDescriptionA frog has just learned some number theory, and can’t wait to show his ability to his girlfriend. Now the frog is sitting on a grid map of infinite rows and columns. Rows are numbere
奇技淫巧之 编译优化
03-16 584
　　emmmm，这四行加上去不要太爽@。@！不过有时会出错。 1 #pragma comment(linker, "/stack:200000000") 2 #pragma GCC optimize("Ofast,no-stack-protector") 3 #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,...
2013 icpc 成都 (5.19)
lbltyyj的博客
05-28 282
A - Assignment For Princess 题目链接https://vjudge.net/contest/230171#problem/A 题解 xjb构造就可以了 先1到n两两连起来i, i+1的权值为i 接下来在满足条件的情况下连i, 1的边 然后在连其他的边就可以了 代码 //#pragma comment(linker, "/stack:20000000...
HDU 5382 GCD?LCM! （递推公式 + 打表）
SHUI
08-19 1080
GCD?LCM! Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 192    Accepted Submission(s): 105 Problem Description First we define:
一些奇怪的东西
mengbi_er的博客
12-05 945
#if !defined(YCM) && 1 #define _FORTIFY_SOURCE 0 #pragma GCC optimize("Ofast,no-stack-protector") #pragma GCC target("avx") #include <stdio.h> #endif #include<iostream> #include<cstdio> #include<cstrin
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
2013 ACM_ICPC 南京赛区网络赛：编程挑战
"2013 ACM_ICPC 南京赛区网络赛题目包含了多个算法和编程挑战，涵盖了不同的计算机科学领域。 1. ProblemA - Area 该问题可能涉及到几何计算，要求参赛者编写程序来计算特定区域。描述部分可能包含如何处理几何形状...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值