2015 ICPC 长春网赛 解题报告

最新推荐文章于 2018-09-29 11:02:45 发布
原创 最新推荐文章于 2018-09-29 11:02:45 发布 · 1.4k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#2015ICPC #长春网赛

本文分享了作者在ACM竞赛中的解题经验，包括如何快速解决简单的“水题”，利用优先队列模拟过程，使用并查集处理图论问题，通过后缀数组寻找最优解等实用技巧。

        只A了几道水题，还好晋级了。

07 The Water Problem

        果然是水题，随便模拟一下就好了。为了题解完整性贴出来。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
using namespace std;   

int a[1010];

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;    cin>>n;
        for(int i=1;i<=n;i++){
            scanf("%d",a+i);
        }
        int q;
        cin>>q;
        int l,r;
        for(int i=1;i<=q;i++){
            scanf("%d%d",&l,&r);
            int ans=-1;
            for(int j=l;j<=r;j++){
                if(a[j]>ans){
                    ans=a[j];
                }
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}


02 Ponds

        这题只要维护每个点的度就可以了，度小于2的点删掉，并减少相关点的度。用队列维护，删到不能再删，最后dfs统计一下奇数个点的连通分量。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
#include <queue>
using namespace std;   

const int maxn=10010;
const int maxm=200010;

int a[maxn];

int head[maxn];
int pre[maxm];
int to[maxm];

int deg[maxn];
int tote;
bool vis[maxn];
bool removed[maxn];

int init(){
    memset(head,-1,sizeof(head));
    tote=0;
    memset(removed,0,sizeof(removed));
    memset(vis,0,sizeof(vis));
    memset(deg,0,sizeof(deg));
}

void addedge(int u,int v){
    to[tote]=v;
    pre[tote]=head[u];
    head[u]=tote++;
    //
    to[tote]=u;
    pre[tote]=head[v];
    head[v]=tote++;
}

#define ll long long
ll cur;

int dfs(int u){
    vis[u]=1;
    int re=1;
    cur+=a[u];
    for(int i=head[u];~i;i=pre[i]){
        int v=to[i];
        if(removed[v])continue;
        if(vis[v])continue;
        re+=dfs(v);
    }
    return re;
}

int main(){
    int t;
    cin>>t;
    while(t--){
        init();
        int n,m;    
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            scanf("%d",a+i);
        } 
        
        for(int i=1;i<=m;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            addedge(u,v);
            deg[u]++;
            deg[v]++;
        }
        
        queue<int> que;
        for(int i=1;i<=n;i++){
            if(deg[i]<2){
                que.push(i);
            }
        }
        
        while(que.size()){
            int u=que.front();    que.pop();
            removed[u]=1;
            for(int i=head[u];~i;i=pre[i]){
                int v=to[i];
                if(removed[v])continue;
                deg[v]--;
                if(deg[v]<2){
                    que.push(v);
                }
            }
        }

        long long ans=0;
        
        for(int i=1;i<=n;i++){
            if(removed[i])continue;
            if(vis[i])continue;
            cur=0;
            int cnt = dfs(i);
            if(cnt&1){
                ans+=cur;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

05 Travel

        把询问离线，排序，先处理小的再处理大的。然后就是并查集，合并边小于等于当前询问的点，维护集合大小。对于每个集合来说，贡献就是size*(size-1)。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
#include <queue>
using namespace std;   

const int maxn=20010;
const int maxm=100010;
const int maxq=5010;

#define ll long long

struct edge{
    int u,v,len;
    edge(int u,int v,int len):u(u),v(v),len(len){
    }
    edge(){
    }
    bool operator<(const edge& other)const{
        return len<other.len;
    }
}edges[maxm];

struct Q{
    int qq;
    int id;
    ll ans;
    bool operator<(const Q& other)const{
        return qq<other.qq;
    }
}Qs[maxq];

ll ans[maxq];

int shi_si[20005];
int shi_f[20005];

void init(int n){
    
    for(int i=1;i<=n;i++){
        shi_si[i]=1;
        shi_f[i]=i;
    }
}

int get_fa(int x){
    if(shi_f[x]==x){
        return x;
    }else{
        int re=get_fa(shi_f[x]);
        shi_f[x]=re;
        return re;
    }
}

int unit(int a,int b){
    int fa = get_fa(a);
    int fb = get_fa(b);
    if(shi_si[fa] > shi_si[fb]){
        shi_f[fb] = fa;
        shi_si[fa] += shi_si[fb]; 
    } 
    else{
        shi_f[fa] = fb;
        shi_si[fb] += shi_si[fa];
    }
}

ll calc(ll sz){
    return sz*(sz+1);
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n,m,q;
        cin>>n>>m>>q;
        init(n);
        for(int i=0;i<m;i++){
            int u,v,len;
            scanf("%d%d%d",&u,&v,&len);
            edges[i]=edge(u,v,len);
        }
        sort(edges,edges+m);
        
        for(int i=1;i<=q;i++){
            scanf("%d",&Qs[i].qq);
            Qs[i].id=i;
        }
        sort(Qs+1,Qs+1+q);
        
        int pos=0;
        ll curans=0;
        for(int i=1;i<=q;i++){
            while(edges[pos].len<=Qs[i].qq&&pos<m){
                int u=edges[pos].u;
                int v=edges[pos].v;
                int sizeu=0;
                int sizev=0;
                int fu=get_fa(u);
                int fv=get_fa(v);
                pos++;
                if(fu==fv){
                    continue;
                }
                curans-=calc(shi_si[fu]);
                curans-=calc(shi_si[fv]);
                unit(u,v);
                int fff=get_fa(u);
                curans+=calc(shi_si[fff]);
            }
            Qs[i].ans=curans;
        }
        
        for(int i=1;i<=q;i++){
            int target=Qs[i].id;
            ans[target]=Qs[i].ans;
        }
        
        for(int i=1;i<=q;i++){
            printf("%I64d\n",ans[i]);
        }
    }
    return 0;
}

01 Alisha’s Party

        这题卡着时限过的。。其实很简单，就是用优先队列模拟过程，开门时间用数组来存比较好，注意最后会全放进去。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
#include <queue>
#include <map>
using namespace std;   

int k, m, q;

int t[150005];
int p[150005];

int ans[150005];

struct node {
    char s[205];
    int id;
    int v;
    bool operator < (const node& a) const {//?
        if(v == a.v) return a.id < id;
        return v < a.v;
    }
}person[150005];

int open[150005]; 

void init(){
    memset(open,0,sizeof(open));
}

int main() {
    int T;
    cin >> T;
    while(T --) {
        init();
        cin >> k >> m >> q;	//人数 开门数 查询数 
        for(int i = 1; i <= k; i ++) {
            scanf("%s",person[i].s);
            scanf("%d", &person[i].v);
            person[i].id = i;
        }
        for(int i = 1; i <= m; i ++) {
            int t,p;
            scanf("%d %d", &t, &p);
            open[t]+=p;
        }
        open[k]=k;
        
        priority_queue<node> que;
        
        int rank=1;
        for(int i=1;i<=k;i++){
            que.push(person[i]);
            while(open[i]--){
                if(que.size()==0){
                    break;
                }
                node tmp=que.top();    que.pop();
                ans[rank++]=tmp.id;
            }
        }
        
        for(int i = 1; i <= q; i ++) {
            int t;
            scanf("%d", &t);
            printf("%s",person[ans[t]].s);
            if(i != q) {
                printf(" ");
            }
            else {
                printf("\n");
            }
        }
    }
    return 0;
}

08 Elven Postman

        首先给的结构是二叉树，所以左子树在东边，右子树在西边。对于每个子树，根据根的大小就能够知道它的左右子树的大小。递归一下，找出以每个节点为根的左子树大小就可以模拟走路过程了。从根开始走，如果根小了往西，否则往东。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
#include <queue>
#include <map>
using namespace std;   

const int maxn=1010;

int rangel[maxn];
int ranger[maxn];
int a[maxn];
int lsize[maxn];
 
void fun(int root,int ll,int rr){
    if(ll==rr)return;
    rangel[root]=ll;
    ranger[root]=rr;
    lsize[root]=a[root]-ll;
    if(a[root]!=ll)fun(root+1,ll,ll+lsize[root]-1);
    if(a[root]!=rr)fun(root+lsize[root]+1,a[root]+1,rr);
}

int main() {
    int T;
    cin >> T;
    while(T--){
        int n;
        cin>>n;
        for(int i=1;i<=n;i++){
            scanf("%d",a+i);
        }
        fun(1,1,n);
        
        int q;
        cin>>q;
        while(q--){
            int b;
            scanf("%d",&b);
            int cur=1;
            while(1){
                if(a[cur]==b){
                    printf("\n");
                    break;
                }else if(a[cur]>b){
                    cur++;
                    printf("E");
                }else{
                    cur+=lsize[cur]+1;
                    printf("W");
                }
            }
        }
    }
    return 0;
}

10 Unknown Treasure

        这题学弟过的。数论渣表示并不会Orz。一会补题。


06 Favorite Donut

        后缀数组。简单来说求的就是字符串的最大字典序，这可以根据SA的rank数组得到。正序重叠跑SA，逆序重叠再跑SA。要注意题目的各种要求，优先起点下标小，优先顺时针。为了做到这一点，需要在逆串重叠后加一个大字符，在正串最大和逆串最大相等的情况下要特判。需要考虑许多细节，见代码。这题最后2min绝杀，真心爽。

#include <iostream>   
#include <cstdio>   
#include <algorithm>   
#include <set>  
#include <vector>  
#include <string.h>  
#include <queue>
#include <map>
using namespace std;   

const int Max=40010;
char str[Max];
char old[Max];

int num[Max];  
int sa[Max], Rank[Max], height[Max];  
int wa[Max], wb[Max], wv[Max], wd[Max];  
  
int cmp(int *r, int a, int b, int l){  
    return r[a] == r[b] && r[a+l] == r[b+l];  
}  
  
void da(int *r, int n, int m){          //  倍增算法 r为待匹配数组  n为总长度 m为字符范围  
    int i, j, p, *x = wa, *y = wb, *t;  
    for(i = 0; i < m; i ++) wd[i] = 0;  
    for(i = 0; i < n; i ++) wd[x[i]=r[i]] ++;  
    for(i = 1; i < m; i ++) wd[i] += wd[i-1];  
    for(i = n-1; i >= 0; i --) sa[-- wd[x[i]]] = i;  
    for(j = 1, p = 1; p < n; j *= 2, m = p){  
        for(p = 0, i = n-j; i < n; i ++) y[p ++] = i;  
        for(i = 0; i < n; i ++) if(sa[i] >= j) y[p ++] = sa[i] - j;  
        for(i = 0; i < n; i ++) wv[i] = x[y[i]];  
        for(i = 0; i < m; i ++) wd[i] = 0;  
        for(i = 0; i < n; i ++) wd[wv[i]] ++;  
        for(i = 1; i < m; i ++) wd[i] += wd[i-1];  
        for(i = n-1; i >= 0; i --) sa[-- wd[wv[i]]] = y[i];  
        for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i ++){  
            x[sa[i]] = cmp(y, sa[i-1], sa[i], j) ? p - 1: p ++;  
        }  
    }  
}  
  
void calHeight(int *r, int n){           //  求height数组。  
    int i, j, k = 0;  
    for(i = 1; i <= n; i ++) Rank[sa[i]] = i;  
    for(i = 0; i < n; height[Rank[i ++]] = k){  
        for(k ? k -- : 0, j = sa[Rank[i]-1]; r[i+k] == r[j+k]; k ++);  
    }  
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        scanf("%s",str);
        for(int i=0;i<n;i++){
            str[i+n]=str[i];
        }
        str[n*2]='\0';

        int i,m=30;
        int len=2*n;  
        for(int i=0;i<=len;i++){
            old[i]=str[i];
        }
        for(i=0;i<=len;i++)num[i]=str[i]-'a'+1;  
        num[len]=0;  
        da(num, len + 1, m);  
        calHeight(num, len);  

        int MMMAX=-1;
        int ans=0;
        for(int i=0;i<n;i++){
            if(Rank[i]>MMMAX){
                MMMAX=Rank[i];
                ans=i;
            }
        }
        
        
        reverse(str,str+len);
        str[len]='z'+1;
        str[len+1]='\0';
        len++;
        
        for(i=0;i<=len;i++)num[i]=str[i]-'a'+1;  
        num[len]=0;  
        da(num, len + 1, m);  
        calHeight(num, len);  

        MMMAX=-1;
        int ans2=0;
        for(int i=0;i<n;i++){
            if(Rank[i]>MMMAX){
                MMMAX=Rank[i];
                ans2=i;
            }
        }
        
        int dir=0;
        bool eq=0;
        for(int i=0;i<n;i++){
            if(str[ans2+i]>old[ans+i]){
                dir=1;
                break;
            }else if(str[ans2+i]<old[ans+i]){
                break;
            }else{
                if(i==n-1){
                    eq=1;
                }
            }
        }
        ans2=n-ans2-1;
        if(eq&&ans2<ans){
            dir=1;
        }
        if(dir==0){
            printf("%d %d\n",ans+1,dir);
        }else{
            printf("%d %d\n",ans2+1,dir);
        }
    }
    return 0;
}



Facebook Hacker Cup 2015 Round 1 解题报告
A Cube Master
01-19 1480
Homework         求一个区间[A,B]中素因数个数为K的数有多少个。做法是dp。对每个数i，找到它的某一个素因数d，i的结果就由i/d推得。找的方法是修改筛法。 #include #include #include #include #include #include #include #include #include using namespace
2015 ACM/ICPC 长春现场赛 部分题解
I good vegetable a!
09-04 1940
昨天全队做了这个比赛，做一个小小的总结，写一写部分题的题解。 【E - Rebuild】https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=5199 【题意】依次输入n个点的坐标，分别为圆心。保证相邻圆心的距离是个正整数。第n个圆和第1个圆相
2015年ACM/ICPC长春赛区 J题（01字典树）
LSD20164388的博客
09-29 383
题目链接： https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&amp;Itemid=8&amp;page=show_problem&amp;problem=5204   题意： 给你n(n&lt;=1000)个数，让你选三个数a[i],a[j],a[k](i!=j&amp;&amp;i!=k&amp;...
2015 ACM ICPC 长春赛区 网络赛 HDU 5437 Alisha’s Party
colorfulshark
09-14 953
Alisha’s Party Time Limit: 3000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 980    Accepted Submission(s): 266 Problem Description Princess Alis
HDU 5441 2015年长春icpc网络赛 并查集
转角的守望
11-30 342
Travel Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 4204    Accepted Submission(s): 1408 Problem Description Jack likes to travel
2015 ACM/ICPC 长春现场赛
w20810的专栏
11-01 1550
<题目链接>hdu
2015ACM/ICPC亚洲区长春站 A hdu 5527 Too Rich
anmob303090的博客
11-04 256
Too Rich Time Limit: 6000/3000 MS (Java/Others)Memory Limit: 262144/262144 K (Java/Others)Total Submission(s): 245Accepted Submission(s): 76 Problem Description You are a rich person, ...
2015长春网络赛 ACM/ICPC Asia Regional Changchun Online
TaoSama's Microcosm
09-13 2540
1001 Alisha’s Party 题意: m个 t p 二元组对 表示t-th来到门前 放p个人进来 按照权值从大到小放  最终还要再开一次门把所有人放进来 分析: 优先队列或者set模拟 然后注意二元组要先排序。。。 赛上因为这个wa了好几发 代码: // // Created by TaoSama on 2015-09-13 // Copyright (c) 2015 T
Codeforces VK Cup 2016 - Round 1 (Div. 2 Edition)
热门推荐
A Cube Master
04-01 2万+
A. Bear and Reverse Radewoosh　　按要求计算一下即可。#include <bits/stdc++.h>#define ll long longusing namespace std;int p[111]; int t[111];int main(){ int n,c; cin>>n>>c; for(int i=1;i<=n;i++){
河南省第七届ACM大学生程序设计竞赛 解题报告
A Cube Master
04-23 3330
这两天把去年省赛的题挂到了OJ上，顺便练手。 A.物资调度 DP，类似01背包。dp(i,j)表示情况数，第一维表示考察到第i种物资，第二维表示总数量为j。显然，如果按照题目给的数据范围，答案会超出64位整型的范围，但是题目并没有要求取模，只能说数据太弱。 B.海岛争霸 Floyd算法，稍微修改一下状态转移方程就可以了。Floyd是求和，这题是取最大。 C.机器人
Google Code Jam 2015 Round 1A 解题报告
A Cube Master
04-18 2350
太弱了，比赛时只出了A的大数据和BC小数据，排到1700+。赛后才把B的小数据过了。 A. Mushroom Monster         就是贪心模拟。第一种吃法，只有当前时刻比10秒前少才去吃减少的量，否则不吃。第二种吃法，计算每十秒的减少量，以减少量最大的作为平均速率去吃。 #include using namespace std; int m[10010];
2015 百度之星初赛1 解题报告
A Cube Master
05-30 1776
1001 超级赛亚ACMer         贪心。首先击败战斗力不大于m的最强者，每次去找可以增强战斗力，然后能击败的最强者，把自己战斗力增加到和他一样去打。如果能打败最强的对手，就可以了。 1002 找连续数         离散化，离线按k从1~1000递增的顺序，维护以每个位置为起点长度为k的最小值，最大值，以及是否有相同数。如果MAX-MIN=k-1且没有相同数，长度为k的
福州大学第十二届程序设计竞赛 解题报告
A Cube Master
05-03 1379
由于这个OJ比较蛋疼，比赛时提交的代码看不到，所以就不附代码了，只说思路。 A 非提的救赎         待补。 B 完美的数字         求一个区间内，所有数的“完美度”的和，完美度定义为数i能分解为多少组i=A*A*B(A         预处理算出每个数的平方、立方。写一个函数fun(x)计算区间1~x的结果，题目的答案就是fun(b)-fun(a-1)。在
Google Code jam Qualification Round 2015 解题报告
A Cube Master
04-12 1316
Problem A. Standing Ovation         题目说的是有许多观众，每个观众有一定的羞涩值，只有现场站起来鼓掌的人数达到该值才会站起来鼓掌，问最少添加多少羞涩值任意的人，才能使所有人都站起来鼓掌。         贪心模拟一下就好，添加的人默认让他们羞涩值为0，扫一遍，让加到刚好够就行。 #include #include #include #includ
Codeforces Round #291 (Div. 2) 解题报告 (A B C D)
A Cube Master
02-16 1149
A Chewbaсca and Number         贪心，每一位取t和9-t中较小的。注意首位不能为0。 #include #include #include #include #include #include #include #include #include #include using namespace
2012 ACM-ICPC 杭州站解题报告（4道签到题）
A Cube Master
11-11 1130
hdu 4461 The Power of Xiangqi         题意：
Codeforces Round #301 (Div. 2) 解题报告(ABCD)
A Cube Master
05-01 1048
A Combination Lock         n位0~9密码锁两种状态之间，问最少拨多少次。注意可能越过'0'。直接上代码。。 #include using namespace std; char num1[1010]; char num2[1010]; int main(){ int n; cin>>n; cin>>num1>>num2; int ans=0;
Codeforces Round #273 (Div. 2) 解题报告 (A B C D)
A Cube Master
10-17 1023
A. Initial Bet
ACM/ICPC入门与提高解题报告精选
## ACM/ICPC 解题报告知识点 ### ACM/ICPC 竞赛介绍 ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM-ICPC或ICPC）是一项面向全球大学生的计算机程序设计竞赛。这项竞赛由...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值