训练20191007 2017-2018 ACM-ICPC Latin American Regional Programming Contest

2017-2018 ACM-ICPC Latin American Regional Programming Contest

试题地址:http://codeforces.com/gym/101889

总体情况

总共通过7题CEFGHIJ。其中我完成HIJ三题。纯属被大佬带飞系列。

解题报告

H - Hard choice

签到题

#include <bits/stdc++.h>
using namespace std;

int a1,b1,c1,a2,b2,c2;

int main() {
    cin>>a1>>b1>>c1>>a2>>b2>>c2;
    cout<<max(a2-a1,0)+max(b2-b1,0)+max(c2-c1,0)<<endl;
}

I - Imperial roads

比较裸,类似求次小生成树。这里写的是树链剖分+Kruskal,当然用树上倍增或者LCT维护都很棒。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1000005;

struct Edge {
    int u,v,w;
    bool operator < (const Edge &b) const {
        return w<b.w;
    }
};

struct Ed {
    int u,v,w;
    bool operator < (const Ed &b) const {
        if(u==b.u) return v<b.v;
        else return u<b.u;
    }
    bool operator > (const Ed &b) const {
        if(u==b.u) return v>b.v;
        else return u>b.u;
    }
    bool operator == (const Ed &b) const {
        return u==b.u && v==b.v;
    }
    bool operator >= (const Ed &b) const {
        return *this>b || *this==b;
    }
    bool operator <= (const Ed &b) const {
        return *this<b || *this==b;
    }
};

int n,m,q,t1,t2,t3,t4;
Edge e[N]; Ed E[N];
bool f[N];
vector <pair<int,int> > g[N];

namespace Kruskal {
    int fa[N],ans;
    int find(int x) {
        return fa[x]==x?x:fa[x]=find(fa[x]);
    }
    void merge(int p,int q) {
        p=find(p); q=find(q); fa[p]=q;
    }
    void solve() {
        sort(e+1,e+m+1);
        for(int i=1;i<=n;i++) fa[i]=i;
        for(int i=1;i<=m;i++) {
            if(find(e[i].u)!=find(e[i].v)) {
                merge(e[i].u,e[i].v);
                ans+=e[i].w;
                f[i]=true;
                g[e[i].u].push_back(make_pair(e[i].v,e[i].w));
                g[e[i].v].push_back(make_pair(e[i].u,e[i].w));
            }
        }
    }
}

namespace SegmentTree {
    int a[N<<2],b[N<<2];
    void build(int p,int l,int r,int *src) {
        if(l==r) a[p]=src[l];
        else {
            build(p*2,l,(l+r)/2,src);
            build(p*2+1,(l+r)/2+1,r,src);
            a[p]=max(a[p*2],a[p*2+1]);
            if(a[p*2]<a[p]) b[p]=a[p*2];
            else if(a[p*2+1]<a[p]) b[p]=a[p*2+1];
            else b[p]=max(b[p*2],b[p*2+1]);
        }
    }
    int query(int p,int l,int r,int ql,int qr) {
        if(l>qr||r<ql) return 0;
        if(l>=ql && r<=qr) return a[p];
        return max(query(p*2,l,(l+r)/2,ql,qr),query(p*2+1,(l+r)/2+1,r,ql,qr));
    }
    int querys(int p,int l,int r,int ql,int qr) {
        if(l>qr||r<ql) return 0;
        if(l>=ql && r<=qr) return b[p];
        return max(querys(p*2,l,(l+r)/2,ql,qr),querys(p*2+1,(l+r)/2+1,r,ql,qr));
    }
}

namespace Tree {
    int ind,fa[N],siz[N],dep[N],dis[N],vis[N],wson[N],top[N],dfn[N];
    void dfs1(int p) {
        vis[p]=1; siz[p]=1;
        for(int i=0;i<g[p].size();i++) {
            int q=g[p][i].first;
            if(vis[q]) continue;
            dep[q]=dep[p]+1;
            dis[q]=g[p][i].second;
            fa[q]=p;
            dfs1(q);
            siz[p]+=siz[q];
            if(siz[wson[p]]<siz[q]) wson[p]=q;
        }
    }
    void dfs2(int p) {
        vis[p]=1;
        dfn[p]=++ind;
        if(wson[p]) {
            top[wson[p]]=top[p];
            dfs2(wson[p]);
        }
        for(int i=0;i<g[p].size();i++) {
            int q=g[p][i].first;
            if(vis[q]) continue;
            top[q]=q;
            dfs2(q);
        }
    }
    void presolve() {
        dfs1(1);
        memset(vis,0,sizeof vis);
        top[1]=1;
        dfs2(1);
    }
    int query(int p,int q) {
        int ret=0;
        while(top[p]!=top[q]) {
            if(dep[top[p]]<dep[top[q]]) swap(p,q);
            ret = max(ret,SegmentTree::query(1,1,n,dfn[top[p]],dfn[p]));
            p=fa[top[p]];
        }
        if(dep[p]>dep[q]) swap(p,q);
        return max(ret,SegmentTree::query(1,1,n,dfn[p]+1,dfn[q]));
    }
    /*int querys(int p,int q) {
        int ret=0, lim=query(p,q);
        while(top[p]!=top[q]) {
            if(dep[top[p]]<dep[top[q]]) swap(p,q);
            if(SegmentTree::query(1,1,n,dfn[top[p]],dfn[p])<lim)
                ret=max(ret,SegmentTree::query(1,1,n,dfn[top[p]],dfn[p]));
            else
                ret=max(ret,SegmentTree::querys(1,1,n,dfn[top[p]],dfn[p]));
            p=fa[top[p]];
        }
        if(dep[p]>dep[q]) swap(p,q);
        if(SegmentTree::query(1,1,n,dfn[p]+1,dfn[q])<lim)
            return max(ret,SegmentTree::query(1,1,n,dfn[p]+1,dfn[q]));
        else
            return max(ret,SegmentTree::query(1,1,n,dfn[p]+1,dfn[q]));
    }*/
}

int val[N];

int main() {
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) {
        scanf("%d%d%d",&t1,&t2,&t3);
        e[i].u=t1;
        e[i].v=t2;
        e[i].w=t3;
        E[i].u=t1;
        E[i].v=t2;
        E[i].w=t3;
    }
    sort(E+1,E+m+1);
    Kruskal::solve();
    Tree::presolve();
    for(int i=1;i<=n;i++) {
        val[Tree::dfn[i]]=Tree::dis[i];
    }
    SegmentTree::build(1,1,n,val);
    int ans = Kruskal::ans;
    scanf("%d",&q);
    for(int i=1;i<=q;i++) {
        scanf("%d%d",&t1,&t2);
        Ed qe;
        qe.u = t1; qe.v = t2;
        int eid = lower_bound(E+1,E+m+1,qe) - E;
        cout<<ans + E[eid].w - Tree::query(t1,t2)<<endl;
    }
}

J - Jumping frog

容易发现,步数\(k\)可行的充要条件是 \((n,k)\) 可行。于是可以按照 \((n,k)\) 对集合 \(K\) 划分等价类,只需要检验集合 \(D = \{d: d|n\}\) 中的所有元素即可。容易发现对任意 \(d \in D\),只需要检查是否存在 \(x \in [0,d)\) 使得对任意 \(x+id\) 位置是 Rock。计算答案只要统计所有合法等价类的大小之和即可。

划分等价类时求解若干次GCD,时间复杂度 \(O(n \log{n})\)。检查只需要 \(O(n)\) 扫描,而等价类个数 \(|D|\) ,等于 \((n,k)\) 的所有可能取值。考虑到若\(g=(n,k)\),则必有 \(g|n\),因此 \(|D|+1\) 即为 \(n\) 的因数个数。根据因数个数定理容易证明, \(n\) 的因数个数有渐进上界\(O(\sqrt{n})\),于是总体时间复杂度为 \(O(n \sqrt{n})\)。

#include <bits/stdc++.h>
using namespace std;

int n;
char s[100005];

vector <int> d;
int dsize[100005],buf[100005];

int gcd(int a,int b) {
    return !b?a:gcd(b,a%b);
}

bool check(int k) {
    memset(buf,0,sizeof buf);
    for(int i=0;i<n;i++) if(s[i]=='P') buf[i%k]++;
    for(int i=0;i<k;i++) if(buf[i]==0) return true;
    return false;
}

int main() {
    ios::sync_with_stdio(false);
    cin>>s;
    n=strlen(s);
    for(int i=1;i<n;i++) {
        if(n%i==0) d.push_back(i);
    }
    for(int i=1;i<n;i++) {
        dsize[gcd(i,n)]++;
    }
    int ans = 0;
    for(int i=0;i<d.size();i++) {
        if(check(d[i])) ans += dsize[d[i]];
    }
    cout<<ans<<endl;
}

原文地址:https://www.cnblogs.com/mollnn/p/11632090.html

时间: 2024-10-08 11:30:27

训练20191007 2017-2018 ACM-ICPC Latin American Regional Programming Contest的相关文章

2017-2018 ACM-ICPC Latin American Regional Programming Contest Solution

A - Arranging tiles 留坑. B - Buggy ICPC 题意:给出一个字符串,然后有两条规则,如果打出一个辅音字母,直接接在原字符串后面,如果打出一个元音字母,那么接在原来的字符串后面之后再翻转整个字符串,在这两条规则之下,求有多少种打印给定字符串的方法 思路:如果第一个字符是辅音,那么答案为0 如果全是辅音或全是元音,那么答案为1 如果只有一个辅音,答案为len 否则是最中间两个元音中间的辅音字符个数+1 1 #include <bits/stdc++.h> 2 3 u

2017-2018 ACM-ICPC Latin American Regional Programming Contest

题面pdfhttps://codeforc.es/gym/101889/attachments/download/7471/statements-2017-latam-regional.pdf zyn感冒,两个人打.刚开始两题超迅速,40分钟后开始各种写不出,自闭.然后突然又开出两题. 4题全部1A,70名左右应该能稳个银. 说明卡题了可千万不能放弃!虽然可能简单题做不出来,过的多的题目做不出来,也不要放弃去开题. 以及周末这两场都说明一定要胆子大. B---Buggy ICPC[找规律] 题意

2017-2018 ACM-ICPC Latin American Regional Programming Contest GYM101889

挺有意思的一套题,题也没有啥毒瘤了,本来是队切的结果种种原因大家全挂机了. 只补了百人题,一共7个,其他的暂时先不补了,,也不会嘛qwq H:签到 1 #include <bits/stdc++.h> 2 using namespace std; 3 int a[18],b[18]; 4 int main(){ 5 cin>>a[1]>>a[2]>>a[3]>>b[1]>>b[2]>>b[3]; 6 int ans = 0

2019-2020 ACM-ICPC Latin American Regional Programming Contest L - Leverage MDT

#include<map> #include<queue> #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std; #define LL long long const int N=1010; int val[N][N]; int res[N][N]; char c[N][N]; int n,m; bo

2019-2020 ACM-ICPC Latin American Regional Programming Contest I - Improve SPAM 树形dp?

#include<iostream> #include<cstring> #define int long long using namespace std; const int N=4010,mod=1e9+7; int a[N]; int e[N*N],ne[N*N],idx,h[N]; int st[N]; int ans; int ans1[N]; int read() { int res=0,ch,flag=0; if((ch=getchar())=='-') //判断正

2019-2020 ACM-ICPC Latin American Regional Programming Contest A- Algorithm Teaching 二分图

#include<bits/stdc++.h> #define f first #define s second using namespace std; typedef long long ll; const int N=300005; typedef pair<int,int> P; int n,tot,t,V; map<string,int> mp; map<vector<int>,int> mp2; vector<int> G

极角排序——ICPC Latin American Regional Contests 2019 D

这题还是按角度进行极角排序简单点 /* 按亮度从大到小排序,从大的给小的连一条向量,极角排序后所有向量在两个象限内,那么可行,反之不可行 */ #include<bits/stdc++.h> using namespace std; #define N 1005 typedef double db; const db eps=1e-8; const db pi=acos(-1); int sign(db k){ if (k>eps) return 1; else if (k<-ep

2018-2019 ICPC Northwestern European Regional Programming Contest (NWERC 2018)

J题队友犯了初始化的错,白给6发,本来能1A的 B: solver:lzh.czq 就是个拓扑排序 1 #include <bits/stdc++.h> 2 using namespace std; 3 #define ff first 4 #define ss second 5 #define mp make_pair 6 typedef long long ll; 7 typedef pair<int, int> pii; 8 9 vector<int> g[400

2019-2020 ICPC Southwestern European Regional Programming Contest (SWERC 2019-2020)

J想到了卡特兰数,也想到要按最小值分割数组,丢给队友之后两个人都没做出来,傻了 题目链接:https://codeforces.com/gym/102501 B: solver:czq 1 /* basic header */ 2 #include <bits/stdc++.h> 3 /* define */ 4 #define ll long long 5 #define pb emplace_back 6 #define mp make_pair 7 #define eps 1e-8 8