CCPC-Wannafly Summer Camp 2019 全记录

最新推荐文章于 2020-02-02 11:24:26 发布
最新推荐文章于 2020-02-02 11:24:26 发布
阅读量211 收藏
点赞数
原文链接：http://www.cnblogs.com/izcat/p/11274543.html
版权

 // 7.19-7.29 东北大学秦皇岛校区十天训练营，题目都挂在了Vjudge上。训练期间比较忙，没空更博总结，回来继续补题消化。

 

Day1

这天授课主题是简单图论，节奏挺好，wls两小时理完图论里的基本知识点。

下午的赛题就偏入门了（简单图论无疑），只涉及到最短路问题和简单的搜索以及一些奇怪的技巧。（差分约束呢？最小生成树呢？强连通分量呢？）

 

 A - Jzzhu and Cities （补）

把火车线路加上跑Dijkstra就好了，标记火车线路，相等时也要push。在最短路上的火车线路不能被取消，剩下的全部能取消。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 200010;
struct Edge {
    int to;
    bool istrain;
    ll w;
    Edge(int v, bool is, ll ww):to(v), istrain(is), w(ww){}
    bool operator<(const Edge& a)const {
        if(w==a.w) return istrain;  // 非火车节点先更新
        return w > a.w;
    }
};
vector<Edge> G[maxn];

bool vis[maxn];
int d[maxn];

int Dijkstra() {
    memset(d, 0x3f, sizeof(d));
    memset(vis, 0, sizeof(vis));
    d[1] = 0;
    int res = 0;

    priority_queue<Edge> q;
    q.push(Edge(1, 0, 0));
    while(!q.empty()) {
        Edge tmp = q.top(); q.pop();
        int u = tmp.to;
        if(vis[u]) continue;

        vis[u] = 1;
    //    d[u] = tmp.w;
        if(tmp.istrain) ++res;

        for(int i=0;i<G[u].size();i++) {
            int v = G[u][i].to;
            if(!vis[v] && d[v]>=d[u]+G[u][i].w) {
                d[v] = d[u] + G[u][i].w;
                q.push(Edge(v, G[u][i].istrain, d[v]));
            }
        }

    }
    return res;

}

int main() {
    int n, m, k;
    cin>>n>>m>>k;
    int u, v, w;
    for(int i=0;i<m;i++) {
        scanf("%d %d %d", &u, &v, &w);
        G[u].push_back(Edge(v, 0, w));
        G[v].push_back(Edge(u, 0, w));
    }
    for(int i=0;i<k;i++) {
        scanf("%d %d", &v, &w);
        G[1].push_back(Edge(v, 1, w));
        // G[v].push_back(Edge(1, 1, w));
    }

    printf("%d\n", k-Dijkstra());

    return 0;
}
View Code

 

 B - Phillip and Trains 

BFS 注意打标记！！！（虽然只是3*100的地图也要爆内存！）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int n, k, sx;
char mp[3][110];
bool vis[3][110];
struct node {
    int x, y;
    node(int _x, int _y):x(_x), y(_y) {}
};

bool check(int x, int y) {
    if(x<0 || x>2)
        return false;
    if(y>=n)
        return true;
    if(mp[x][y]=='.')
        return true;

    return false;
}

bool bfs() {
    queue<node> q;
    q.push(node(sx, 0));

    while(q.size()) {
        node now = q.front(); q.pop();
        if(now.y>=n) {
            return true;
        }

    //    printf("(%d,%d) -> ", now.x, now.y);
        
        int nx = now.x, ny = now.y+1;
        if(!check(nx, ny))  continue; // 向右走一步

        for(int i=-1;i<=1;i++) {      // 尝试三个方向移动
            nx = now.x + i;
            if(check(nx, ny) && check(nx, ny+1) && check(nx, ny+2) && !vis[nx][ny+2]) {
                q.push(node(nx, ny+2));
                vis[nx][ny+2] = 1;
            }
        }
    }
    return false;
}


int main() {
    int t; cin>>t;
    while(t--) {
        scanf("%d %d", &n, &k);
        getchar();
        memset(vis, 0, sizeof(vis));
        for(int i=0;i<3;i++) {
            scanf("%s", mp[i]);
            
            if(mp[i][0]=='s')
                sx = i;
            
        }
        printf("%s\n", bfs()?"YES":"NO");
    }
    
    return 0;
}
View Code

 

 C - A Mist of Florescence （补）

构造题，技巧就是设计井字形的连通块，把其他颜色块涂到井字的格子上。

#include<iostream>
#include<cstdio>
using namespace std;

int a, b, c, d;
char ans[50][50];
void solve() {
    for(int i=1;i<=12;i++) {
        for(int j=1;j<50;j++) {
            if(i%2==1 && j%2==1 && a) ans[i][j] = 'A', --a;
            else ans[i][j] = 'D';
        }
    }

    for(int i=13;i<=24;i++) {
        for(int j=1;j<50;j++) {
            if(i%2==1 && j%2==1 && b) ans[i][j] = 'B', --b;
            else ans[i][j] = 'D';
        }
    }

    --c;
    --d;
    for(int i=25;i<=36;i++) {
        for(int j=1;j<50;j++) {
            if(i%2==1 && j%2==1 && c) ans[i][j] = 'C', --c;
            else ans[i][j] = 'D';
        }
    }

    for(int j=1;j<50;j++) {
        ans[37][j] = 'C';
    }

    for(int i=38;i<50;i++) {
        for(int j=1;j<50;j++) {
            if(i%2==1 && j%2==1 && d) ans[i][j] = 'D', --d;
            else ans[i][j] = 'C';
        }
    }


}
int main() {
    cin>>a>>b>>c>>d;
    solve();
    printf("49 49\n");
    for(int i=1;i<50;i++) {
        for(int j=1;j<50;j++)
            printf("%c", ans[i][j]);
        printf("\n");
    }
    
    return 0;
}
View Code

 

 E - Igor In the Museum 

DFS到墙的边界 对每块编号！

#include<iostream>
#include<cstdio>
using namespace std;

int n, m, k;
char mp[1010][1010];
int v[1010][1010], id;  // v[i][j]: mp[i][j]的分类编号   id: 当前编号
int res[1010*1010];        // res[id]: 第id块的答案

const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};

int ans;
void dfs(int x, int y) {
    if(mp[x][y]=='*') {
        ans++;
        return;
    }
    v[x][y] = id;
    for(int i=0;i<4;i++) {
        int nx = x+dx[i], ny = y+dy[i];
        if(nx>=0 && nx<m && ny>=0 && ny<n && !v[nx][ny]) {
            dfs(nx, ny);
        }
    }
}
int main() {
    scanf("%d %d %d", &m, &n, &k);
    getchar();
    for(int i=0;i<m;i++) {
        scanf("%s", mp[i]);
    }

    for(int i=0;i<m;i++) {
        for(int j=0;j<n;j++) {
            if(mp[i][j]=='.' && !v[i][j]) {
                ++id;
                ans = 0;
                dfs(i, j);
                res[id] = ans;
            } 
        }
    }

    while(k--) {
        int x, y;
        scanf("%d %d", &x, &y);
        printf("%d\n", res[v[x-1][y-1]]);
    }

    return 0;
}
View Code

 

 F - The Cild and Toy （补）

贪心！由于每去掉一个点，等价于去掉了所有与它相连的边，就是问去掉全部边的最小代价。答案当然就是每条边两个节点权值小的那头的总和。都不用建图！！

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1010;
int n, m;
int w[maxn];

int main() {
    cin>>n>>m;
    for(int i=1;i<=n;i++) {
        scanf("%d", &w[i]);
    }
    int u, v, ans = 0;
    for(int i=0;i<m;i++) {
        scanf("%d %d", &u, &v);
        ans += min(w[u], w[v]);
    }
    printf("%d\n", ans);
    
    return 0;
}
View Code

 

 G - New Year Permutation

对连通部分排序就完事了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
int n, num[310], id;
int mp[310][310];
bool vis[310];

int ans[310];
struct list {
    vector<int> num;
    vector<int> id;
}L[310];

void dfs(int x, int id) {
    vis[x] = 1;

    L[id].num.push_back(num[x]);
    L[id].id.push_back(x);

    for(int i=1;i<=n;i++) {
        if(mp[x][i]) {
            if(!vis[i])
                dfs(i, id);
        }
    }
}

int main() {
    cin>>n;
    for(int i=1;i<=n;i++) {
        scanf("%d", &num[i]);
    }
    for(int i=1;i<=n;i++) {
        for(int j=1;j<=n;j++) {
            scanf("%1d", &mp[i][j]);
        }
    }

    for(int i=1;i<=n;i++) {
        if(!vis[i])
            dfs(i, ++id);
    }

    for(int i=1;i<=id;i++) {
        // for(int j=0;j<L[i].num.size();j++) {
        //     printf("%d:%d ", L[i].num[j], L[i].id[j]);
        // }
        // cout<<endl;
        
        sort(L[i].num.begin(), L[i].num.end());
        sort(L[i].id.begin(), L[i].id.end());


        for(int j=0;j<L[i].num.size();j++) {
            ans[L[i].id[j]] = L[i].num[j];
        }
    }
    for(int i=1;i<=n;i++) {
        printf("%d%c", ans[i], i!=n?' ':'\n');
    }
    return 0;
}
View Code

 

 H - Alyona and the Tree （补）

从根开始dfs就好，每个节点为max(0LL, now+w[i])

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 100010;
typedef long long ll;

struct Edge {
    int to;
    ll w;
    Edge(int v, ll ww):to(v), w(ww) {}
};
vector<Edge> G[maxn];
int n, vw[maxn];
int ans;
void dfs(int u, int fa, ll now) {
    for(int i=0;i<G[u].size();i++) {
        int v = G[u][i].to;
        if(v!=fa) {
            if(vw[v]>=now+G[u][i].w) {
                --ans;
                // printf("%d->%d\n", u, v);
                dfs(v, u, max(now+G[u][i].w, 0LL));
            }
        }
    }

}

int main() {
    cin>>n; ans = n;
    for(int i=1;i<=n;i++) {
        scanf("%d", &vw[i]);
    }
    int u, w;
    for(int i=2;i<=n;i++) {
        scanf("%d %d", &u, &w);
        G[i].push_back(Edge(u, w));
        G[u].push_back(Edge(i, w));
    }

    dfs(1, -1, 0);
    printf("%d\n", ans-1);
    return 0;
}
View Code

 

 L - Love Triangle 

假的三元环？？

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 5010;
int n, tot;
int love[maxn], low[maxn];
bool vis[maxn];
bool ans;
void dfs(int u) {
    if(ans) return;

    vis[u] = true;
    low[u] = ++tot;
    int v = love[u];
    if(v && !vis[v]) {
        dfs(v);
        if(love[v] && low[love[v]]==low[u]+2 && love[love[v]]==u) {
            ans = true;
            return;
        }
    }
}

int main() {
    cin>>n;
    for(int i=1;i<=n;i++) {
        scanf("%d", &love[i]);
    }
    ans = false;
    for(int i=1;i<=n;i++) {
        if(!vis[i] && !ans)
            dfs(i);
    }
    printf("%s\n", ans?"YES":"NO");
    return 0;
}
View Code

 

 N - News Distribution 

并查集

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 500100;
int n, m;
int fa[maxn];
int g[maxn], cnt[maxn];

int Find(int x) {
    return fa[x]==x?x:(fa[x]=Find(fa[x]));
}

void Union(int x, int y) {
    int a = Find(x);
    int b = Find(y);
    if(a==b) return;
    fa[a] = b;
}

int main() {
    cin>>n>>m;
    for(int i=1;i<=n;i++) fa[i] = i;
    while(m--) {
        int k;
        scanf("%d", &k);
        for(int i=0;i<k;i++) {
            scanf("%d", &g[i]);
        }
        for(int i=1;i<k;i++) {
            Union(g[0], g[i]);
        }
    }
    for(int i=1;i<=n;i++) {
        cnt[Find(i)]++;
    }
    for(int i=1;i<=n;i++) {
        printf("%d%c", cnt[Find(i)], i!=n?' ':'\n');
    }
    return 0;
}
View Code

 

 O - NP-Hard Problem （补）

二分图裸题。。。

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 100010;
int n, m;
vector<int> G[maxn];
int deg[maxn];
int id[maxn];
vector<int> ans[2];
bool dfs(int u) {
    for(int i=0;i<G[u].size();i++) {
        int v = G[u][i];
        if(!id[v]) {
            id[v] = 3 - id[u];
            if(id[v]==1)
                ans[0].push_back(v);
            else
                ans[1].push_back(v);
            if(!dfs(v)) return false;
        } else if(id[v]==id[u]) return false;
    }
    return true;
}

int main() {
    cin>>n>>m;
    int u, v;
    for(int i=0;i<m;i++) {
        scanf("%d %d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
        ++deg[u];
    }
    for(int i=1;i<=n;i++) {
        if(!deg[i]) continue;

        if(!id[i]) {
            id[i] = 1;
            ans[0].push_back(i);
            if(!dfs(i)) 
                return 0 * printf("-1\n");
        }


    }
    
    for(int k=0;k<=1;k++) {
        printf("%d\n", ans[k].size());
        for(int i=0;i<ans[k].size();i++) {
            printf("%d%c", ans[k][i], i==ans[k].size()-1?'\n':' ');
        }
    }

    return 0;
}
View Code

 

 

Day2

第二天的主题是简单数论，下午挂的是CF上的一场区域赛：2015 ACM National Contest Romania

注意文件读入要求！！！（第一题让我WA了4次样例。。。尝试两种方法写）

 

 A - Por Costel and Azerah

子序列里和为偶数的个数，简单dp（或组合数计算）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const int maxn = 1000100;
int arr[maxn], n;
ll a[maxn], b[maxn];

int main() {
    
    freopen("azerah.in", "r", stdin);
    freopen("azerah.out", "w", stdout);
        int t; cin>>t;
    while(t--) {
        scanf("%d", &n);
        for(int i=1;i<=n;i++) {
            scanf("%lld", &arr[i]);
        }
        a[1] = b[1] = 0;
        if(arr[1]%2==0) b[1] = 1;
        else a[1] = 1;
        for(int i=2;i<=n;i++) {
            if(arr[i]%2==0) {
                b[i] = (b[i-1]*2+1) % mod;
                a[i] = (a[i-1]*2)% mod;
            }else {
                b[i] = (a[i-1] + b[i-1]) %mod;
                a[i] = (a[i-1] + b[i-1] + 1) %mod;
            }
        //    cout<<b[i]<<endl;
        }
        cout<<b[n]<<endl;
    }
    return 0;
}

/*
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const int maxn = 1000100;
int arr[maxn], n;

ll pow(ll a, ll n) {
    ll res = 1;
    while(n) {
        if(n%2) {
            res = res * a %mod;
        }
        a = a*a % mod;
        n >>= 1;
    }
    return res;
}
int main() {
    freopen("azerah.in", "r", stdin);
    freopen("azerah.out", "w", stdout);
    
    int t; cin>>t;
    while(t--) {
        ll odd = 0, even = 0;
        scanf("%d", &n);
        for(int i=1;i<=n;i++) {
            scanf("%lld", &arr[i]);
            if(arr[i]%2==0) even++;
            else odd++;
        }
        if(odd==0)
            cout<<(pow(2, even)-1+mod)%mod<<endl;
        else
            cout<<(pow(2, odd-1)*pow(2, even)%mod-1+mod)%mod<<endl;
    }
    return 0;
}

 */
View Code

 

 B - Por Costel and the Algorithm （补）

给了一段Bellman-Ford代码，调整边的顺序让它最多执行两次。

记录最短路上的边即可，dfs输出边的顺序。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 100100;

int n, m;
struct Edge{
    int to;
    int id;
    ll w;
    Edge(int v, int i, ll _w):to(v), id(i), w(_w) {}
    bool operator<(const Edge& e)const {
        return w > e.w;
    }
};
vector<Edge> G[maxn];

ll d[maxn];
int e[maxn];  // e[v]: 连向v的边的编号
bool path[2*maxn];

void Dijkstra() {
    memset(d, 0x3f, sizeof(d));
    d[1] = 0;

    priority_queue<Edge> q;
    q.push(Edge(1, 0, 0));
    while(!q.empty()) {
        Edge tmp = q.top(); q.pop();
        int u = tmp.to;
        for(int i=0;i<G[u].size();i++) {
            int v = G[u][i].to;
            if(d[v]>d[u]+G[u][i].w) {
                d[v] = d[u] + G[u][i].w;

                path[e[v]] = 0;
                path[G[u][i].id] = 1;
                e[v] = G[u][i].id;

                q.push(Edge(v, 0, d[v]));
            }
        }
    }
}


void dfs(int u) {
    for(int i=0;i<G[u].size();i++) {
        int m = G[u][i].id, v = G[u][i].to;
        //printf("%d->%d %d", u, v, m);
        if(path[m]) {
            printf("%d ", m);
            dfs(v);
        }
    }
}

int main() {
    freopen("algoritm.in", "r", stdin);
    freopen("algoritm.out", "w", stdout);
    int t; cin>>t;
    while(t--) {
        memset(e, 0, sizeof(e));
        memset(path, 0, sizeof(path));
        for(int i=0;i<maxn;i++) G[i].clear();

        scanf("%d %d", &n, &m);
        for(int i=1;i<=m;i++) {
            int u, v; ll w;
            scanf("%d %d %lld", &u, &v, &w);
            G[u].push_back(Edge(v, i, w));
        }
        Dijkstra();

        dfs(1);
        for(int i=1;i<=m;i++) {
            if(!path[i])
                printf("%d ", i);
        }
        printf("\n");
    }
    return 0;
}
View Code

 

 C - Por Costel and Bujor

 D - Por Costel and the Censorship Committee

 E - Por Costel and the Cipher

 F - Por Costel and the Alien Invasion

 G - Por Costel and the Orchard

 

 H - Por Costel and the Match

并查集裸题（可以用带权并查集做？）

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 100010;
int n, m;
int fa[maxn*2];
int Find(int x) {
    return fa[x]==x?x:(fa[x]=Find(fa[x]));
}
 
void Union(int x, int y) {
    int a = Find(x), b= Find(y);
    if(a!=b) 
        fa[a] = b;
}
 
int main() {
    freopen("meciul.in", "r", stdin);
    freopen("meciul.out", "w", stdout);
    int t; cin>>t;
    while(t--) {
        scanf("%d %d", &n, &m);
        for(int i=1;i<=2*n;i++) fa[i] = i;
        int x, y;
        while(m--) {
            scanf("%d %d", &x, &y);
            if(Find(x)!=Find(y) && Find(x+n)!=Find(y+n)) {
                printf("YES\n");
                Union(x, y+n);
                Union(x+n, y);
            } else {
                printf("NO\n");
            }
        }
    }
    return 0;
}
View Code

 

 I - Por Costel and the Match

求[n/i]，分块（也可以只计算k=sqrt(n)的结果，ans*2 - k*k就是最终答案）

ll ans = 0;
for(int i=1;i<=n;) {
    ans += n/i * (n/(n/i) - i +1);
    i = n/(n/i) + 1;
}

 

 J - Por Costel and Pinball

 

 K - Por Costel and the Firecracker （补）

没有内存限制的话就是水题，可是完全没有优化空间。。。

百度之，学会了分块打表

把第一次查询看成了x1，debug了半天。。。

#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
const int maxn = 10000010;
const int mod = 10000003;
ll n, a, b, x1, q, q1;
ll ans[maxn/100+10];
void pre() {
    ans[0] = x1;
    ll last = x1;
    for(ll i=1;i<maxn;i++) {
        last = (last*i % n + a) % n;
        if(i%100==0) {
            ans[i/100] = last;
        }
    //    cout<<i<<' '<<ans[i]<<endl;
    }

}

ll cal(ll k) {
    if(k%100==0) return ans[k/100];
    
    ll last = ans[k/100];
    for(ll i=k/100*100+1;i<=k;i++) {
        last = (last*i % n + a) % n;
    }
    return last;
}

int main() {
    freopen("pocnitoare.in", "r", stdin);
    freopen("pocnitoare.out", "w", stdout);

    cin>>n>>a>>b>>x1>>q>>q1;

    pre();
    printf("%lld\n", x1=cal(q1-1));  // 第一次查询是q1-1而不是x1-1!!!
    for(int i=1;i<q;i++) {
        q1 = (i*x1 % mod + b) % mod + 1;
        printf("%lld\n", x1=cal(q1-1));

    }
    return 0;
}
View Code

 

 L - Por Costel and the Semipalindromes

WA了半天，原来是1左移出现了溢出，ll范围一定要写成 (1LL<<k)

#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
char res[1010];
int tmp[1010];
int main() {
    freopen("semipal.in", "r", stdin);
    freopen("semipal.out", "w", stdout);
    int t; cin>>t;
    while(t--) {
        int n; ll k;
        scanf("%d %lld", &n, &k);
        
        res[1] = res[n] = 'a';

        if(k>(1LL<<(n-2))) {
            k -= (1LL<<(n-2));
            res[1] = res[n] = 'b';
        } 
        --k;
        for(int i=0;i<n-2;i++) {
            tmp[n-1-i] = (k>>i)&1;
        }
        for(int j=2;j<n;j++) {
            if(tmp[j]) {
                res[j] = 'b';
            } else {
                res[j] = 'a';
            }
        }

        for(int i=1;i<=n;i++) {
            putchar(res[i]);
        }
        puts("");
    }
    return 0;
}
View Code

 

 

Day3

题目来自于NAIPC 2016北美邀请赛。

 

 E - K-Inversions

给定一个只含有AB的字符串（长度不超过1000000），求间隔为1~n-1的B-A有多少对。

FFT模板题

 

 

 F - Mountain Scenes

给长度总和为n的木条以及相框的宽度w和高度h，问能组成多少种不同的山峰形状。

大家的签到dp题，我的自闭题。。。 j 没有从0开始样例死都调不出来 噗

也就是dp[i][0] = 1

dp[i][j] 为宽度 i 用了总长 j 的木条的方案数。 dp[i+1][j] = sum( dp[i][j-k] ) ( 0<=k<=h, j )

#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll; 
const int maxn = 10010;
const int mod = 1e9+7;

int n, w, h;
ll dp[110][maxn];
int main() {
    
    cin>>n>>w>>h;
    // for(int i=0;i<=h && i<=w;i++) dp[i][0] = 1;
    dp[0][0] = 1;
    for(int i=1;i<=w;i++) {
         for(int j=0;j<=n;j++) {  // j=0 开始。。。坑死自己了
            for(int k=0;k<=h && k<=j;k++) {
                dp[i][j] = (dp[i][j] + dp[i-1][j-k]) % mod;
            }
        }
    }

    ll ans = 0;
    for(int i=1;i<=n;i++)
        ans = (ans + dp[w][i])%mod;

    cout<<(ans-min(n/w, h))%mod<<endl;
    return 0;
}
View Code

 

 

 G - Symmetry

平面上有 n 个点（ n<=1000），问至少加入多少点，使全部点与某一个点中心对称，或者全部点关于某条过其中两点的直线对称。

计算几何。

对于要求1，枚举全部点再check剩下点是否中心对称，复杂度O(n^2logn)，可行。

对于要求2，枚举两点所得直线再check剩下点是否关于直线对称，复杂度O(n^3logn)，TLE。

看题解好像是把直线去重才能过。

 

 

 I - Tourists

 求树上所有整除关系的两对节点的最短路之和。

 计算所有符合条件的节点复杂度O(nlogn)，树上两点 u, v 的最短路为 dep[u] + dep[v] - 2*dep[lca(u, v)] + 1。

 找了个LCA的板子就1A了 O.O （第四个板子是改进的树链剖分求LCA，复杂度O(n + mlogn)，是其中最快的。）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 500010;
struct Edge {
    int to, next;
}edges[maxn];
int head[maxn], tot;

int fa[maxn], siz[maxn], dep[maxn], top[maxn];
// top[u] == u : u不是重儿子
// top[u] == fa: fa的重儿子是u
void add(int u, int v) {
    edges[++tot].to = v;
    edges[tot].next = head[u];
    head[u] = tot;
}

void dfs(int u) { // 求fa, siz, dep, top
    int maxSon = 0, son = 0;
    top[u] = u;
    siz[u] = 1;
    for(int i=head[u];i;i=edges[i].next) {
        int v = edges[i].to;
        if(v==fa[u]) continue;

        fa[v] = u;
        dep[v] = dep[u] + 1;
        dfs(v);
        siz[u] += siz[v];

        if(siz[v]>maxSon)
            maxSon = siz[son=v];
    }
    if(son)    // 重儿子
        top[son] = u;
}

int Find(int u) {
    return u==top[u]?u:top[u]=Find(top[u]);
}

int LCA(int u, int v) {
    if(Find(u)!=Find(v))
        return dep[top[u]]<dep[top[v]] ? LCA(u, fa[top[v]]):LCA(v, fa[top[u]]);
    else
        return dep[u]<dep[v] ? u:v;
}


int main() {
    int n;
    cin>>n;
    for(int i=0;i<n-1;i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        add(u, v);
        add(v, u);
    }
    memset(fa, -1, sizeof(fa));
    dfs(1);

    long long ans = 0;
    for(int i=1;i<=n/2;i++) {
        for(int j=i*2;j<=n;j+=i) {
            ans += dep[i]+dep[j]-2*dep[LCA(i, j)] + 1;
        }
    }
    printf("%lld\n", ans);
    return 0;
}
View Code

 

 

 

Day4

 A - One-dimensional Japanese Crossword

简单模拟题。

 

 B - Passwords

简单数学题。

 

 C - Journey

 

 

 E - Jamie and Alarm Snooze

简单模拟题。

#include<iostream>
#include<cstdio>
using namespace std;

bool check(int h, int m) {
//    cout<<h<<":"<<m<<endl;
    if(h%10==7 || m%10==7) return true;
    return false;
}
int main()
{
    int x, h, min;
    scanf("%d", &x);
    scanf("%d %d", &h, &min);

    int y = 0;
    while(!check(h, min)) {
        if(x==60) {
            if(--h<0) h = 23;
        } else {
            min -= x;
            if(min<0) {
                min += 60;
                if(--h<0) h = 23;
            }
        }
        ++y;
    }

    printf("%d\n", y);
    return 0;
}
View Code

 

 

 F - Jamie and Binary Sequence (changed after round)

给定 n 和 k，将 n 分解成 k 个二次幂之和，求2的指数最小且字典序最大的一组解，不存在则输出 No。

思维题。

把 n 转成二进制，要保证最高次幂最小，当二进制位1个数小于k时，把最高位2^n拆成 2^(n-1) + 2^(n-1)，这样多了一个1。

当拆分之后1的数量大于k时，要保证字典序最大，再从最低位开始拆分，每次只拆一个1，新的低位加2。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;

ll n;
int k, bits[100100], cnt, high, len;
int tmp[65];

int main()
{
    cin>>n>>k;
    ll nn = n;
    for(int i=0;nn;i++) {
        tmp[i] = nn&1;
        nn >>= 1; 
        len = i;
        if(tmp[i]) ++cnt;
    }
    for(int i=len;i>=0;i--) {
        bits[len-i] = tmp[i];
    }
    high = len;  // 记录最高位指数
    // for(int i=0;i<=len;i++) cout<<bits[i];

    if(cnt>k) return 0 * printf("No\n");

    int pos = 0;
    while(cnt<k) {
        if(cnt+bits[pos]<=k) { // 最小化y=max(ai)
            cnt += bits[pos];
            bits[pos+1] += 2*bits[pos];
            bits[pos] = 0;
            ++pos;
            len = max(pos, len);   // 忘记更新，WA66组
        } else {
            pos = len; 
            while(!bits[pos]) --pos;
            while(cnt<k) {
                ++cnt;
                bits[pos] -= 1;
                bits[++pos] += 2;
                
            }
        }
    }

    printf("Yes\n");
    int up = max(pos, len);
    for(int i=0;i<=up;i++) {
        for(int j=0;j<bits[i];j++)
            printf("%d ", high-i);
    }
    return 0;
}
View Code

 

 

 G - Jamie and Interesting Graph

 需要构造出一个n个节点m条边的图，满足最小生成树的权为素数，1到n的最短路为素数。

 构造1~n的一条链为最小生成树，权为p = 100019。剩下不停加边，边权为2p。

#include<iostream>
#include<cstdio>
using namespace std;
int p = 100019;
int main() {
    int n, m;
    cin>>n>>m;
    printf("%d %d\n", p, p);
    printf("1 2 %d\n", p-(n-2));
    for(int i=2;i<n;i++)
        printf("%d %d 1\n", i, i+1);
    m -= n-1;

    for(int i=1;i<n && m;i++)
    for(int j=i+2;j<=n && m;j++) {
        printf("%d %d %d\n", i, j, 2*p);
        --m;
        
    }

    return  0;
}
View Code

 

 

 H - 树上染色

 很经典的树形dp。

// f[u][j]: 以u为根节点，涂了 j 个黑点的子树对答案的最大贡献

对于一条边，左边子树有 x 个黑点，则右边有 k-x 个黑点，左边白点为 size[v] - x，右边白点为 n - size[v] - (k-x)，按照题意计算这部分贡献 val。

状态转移方程为 f[u][j] = max( f[u][j], f[u][j-x] + f[v][x] + val)，j 倒序枚举更新。

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#define max(x, y) ((x) > (y) ? (x) : (y))
#define min(x, y) ((x) < (y) ? (x) : (y))
using namespace std;
typedef long long ll;
const int maxn = 2010;
struct Edge {
    int u, w;
    Edge(int uu, int ww):u(uu), w(ww) {}
};
vector<Edge> G[maxn];
int siz[maxn], n, kk;
ll f[maxn][maxn];  // f[u][j]: 节点i含有j个黑点的子树对答案的最大贡献

void dfs(int u, int fa) {
    f[u][0] = f[u][1] = 0;
    siz[u] = 1;
    for(int i=0;i<G[u].size();i++) {
        int v = G[u][i].u;
        if(v==fa) continue;
        
        dfs(v, u);
        siz[u] += siz[v];
 
    }
    for(int i=0;i<G[u].size();i++) {
        int v = G[u][i].u, w = G[u][i].w;
        if(v==fa) continue;
        
        for(int j=min(kk, siz[u]);j>=0;j--) {
            for(int k=0;k<=min(j, siz[v]);k++) {
                if(f[u][j-k]!=-1) {
                    ll val = (1LL*k*(kk-k)+ 1LL*(siz[v]-k)*(n-kk-(siz[v]-k)))*w;
                    f[u][j] = max(f[u][j], f[u][j-k]+f[v][k]+val);
                }
            }
        }
    }
}


int main() {
    scanf("%d %d", &n, &kk);
    for(int i=1;i<n;i++) {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));

    }
    memset(f, -1, sizeof(f));
    dfs(1, -1);
    printf("%lld\n", f[1][kk]);

    return 0;
}
View Code

 

 

Day5

 

 

Day6

 

转载于:https://www.cnblogs.com/izcat/p/11274543.html

weixin_30697239
关注
CCPC-Wannafly Summer Camp 2019 Day1
YOONGI
08-03 168
CCPC-Wannafly Summer Camp 2019 Day1 比赛链接：https://vjudge.net/contest/312902#overview A：CodeForces 449B Jzzhu and Cities （最短路+思维） B：CodeForces 585B Phillip and Trains （搜索+思维） C：CodeForces ...
【CCPC-Wannafly Winter Camp Day4 (Div2, onsite)】 G 置置置换
我是谁 --- 卡比兽
05-01 158
置置置换 题意 给你 n−1n - 1n−1长度的由&amp;gt;&amp;gt;>和&amp;lt;&amp;lt;<组成的序列 第偶数个括号是&amp;lt;&amp;lt;<代表 第i−1i-1i−1个数字比iii个数字大 奇数个和&amp;gt;&amp;gt;>同理 要满足 1 - n的全排列 所以我们设 dp[i][j] 代表 满足 1 - i 全排列 第 i...
CCPC-Wannafly Summer Camp 2019
git1314的博客
07-23 673
2019暑假CCPC-Camp在东北大学-秦皇岛分校举行 训练营是针对CCPC区域赛银牌及以下的，每天可以在comet上观看直播, 在Vjudge上做题 早上直播时间是早上8：30 - 11：30 晚上讲题 19：00~ 21： 00 直播地址： https://cometoj.com/liveDetail/100000 直播内容： Day 1： Day1-专题-图论（洪华敦） Day2...
CCPC-Wannafly Summer Camp 2019 Day4
YOONGI
08-06 229
CCPC-Wannafly Summer Camp 2019 Day1 比赛链接：https://vjudge.net/contest/314412#overview A - One-dimensional Japanese Crossword CodeForces - 721A 题目链接：http://codeforces.com/problemset/problem/721...
CCPC-Wannafly Summer Camp 2019 Day1 (无 I 题)
Whyckck的博客
08-02 281
比赛链接：https://vjudge.net/contest/312902#overview 目录 A - Jzzhu and Cities B - Phillip and Trains C - A Mist of Florescence D - Unbearable Controversy of Being E - Igor In the Museum F - The Chi...
100923G-Por Costel and the Orchard
Alex Panda的博客
08-13 135
题意：给你一个nm（300300）的矩阵，每个点都有一个权值-1e4-1e4，求最大联通块的权值。 思路： dp其实很好想，dpxij表示第x行i-j区间所联通0-x行的最大权值。 那么压缩到n^3我们需要做几件事情： 在n^2的时间内求出0-x行的与ij的最大权值（预处理） 滚动数组 其实相对不好想的是n^2预处理，类似dp中的dp 不如想想我们n^2可以做什么事情：a. 前缀和求出每个区间的...
知识点 - 后缀数组
qq_41848675的博客
08-20 235
知识点 - 后缀数组 (SA) 解决问题类型： 最小的循环位移（cyclic shift，即字符环中字典序最小） 查找子串 比较两个子串 两个子串的LCP(不需要额外空间) 本质不同的子串数 论文 2009后缀数组——处理字符串的有力工具 罗穗骞 后缀数组 2004 后 缀 数 组 许智磊 后缀数组 blog 定义与代码： sa[i]sa[i]sa[i]表示s串后缀中第 iii 小的后缀...
CCPC-Wannafly Summer Camp #1（部分解题报告）
lived的博客
08-06 1521
A:Birthday 时间限制: 1 Sec  内存限制: 256 MB 题目描述 恬恬的生日临近了。宇扬给她准备了一个大蛋糕。 正如往常一样，宇扬在蛋糕上插了n支蜡烛，并把蛋糕分为m个区域。因为某种原因，他必须把第i根蜡烛插在第ai个区域或第bi个区域。区域之间是不相交的。宇扬在一个区域内同时摆放x支蜡烛就要花费x2的时间。宇扬布置蛋糕所用的总时间是他在每个区域花的时间的和。 宇扬想快...
2020 CCPC-Wannafly Winter Camp Day1_A 期望逆序对
Vibrant
01-22 521
贪心+数学
2020 CCPC-Wannafly Winter Camp Day6 Div.1&2——C.酒馆战棋【模拟】
NIRVANA REBIRTH
02-02 383
题目传送门 题目描述 酒馆战棋是一个很有趣的游戏，这个游戏一共有两名玩家，每个玩家各自控制一定数量的随从，随从从左往右排列。 随从有两个基础属性：攻击力的血量，两个随从交战后会受到对方攻击力的伤害（失去对应的血量），当一个随从的血量降到 0{0}0 或者以下时会死亡。 整个对战流程如下：你的随从从左往右依次进行攻击，每次攻击是随机选择一个可以攻击的对方随从进行攻击。而对方的随从全程不动。 由于对...
CCPC-Wannafly Winter Camp Day2 (Div2, onsite) Erase Numbers II
c3po
01-30 557
题目描述   给定 nn 个正整数 a_1, a_2, \cdots, a_na1​,a2​,⋯,an​，它们组成了序列 AA。 你的任务是删除其中 (n - 2)(n−2) 数字，使得 AA 中剩余的数字连起来的所表示的数字最大，并给出这个值。 严格来讲，如果剩余数字在 AA 中的下标为 p_1, p_2, \cdots, p_mp1​,p2​,⋯,pm​ (1 \leq p_1 &amp;am...
2019年 CCPC-Wannafly Winter Camp 总结及感悟
LSD20164388的博客
01-29 1368
比赛网站：传送门 一、得到的知识训练 1、 dp ①直接dp 数据范围很小(n&amp;lt;=100) 且符合动态规划的题目特征可直接暴力dp，直接用多维（一般三维以上）状态、多重（一般三重以上）for循环完成状态转移，注意题目中的限制条件以及你的初始化，也可以直接交表。 例题：CCPC-Wannafly Winter Camp Day1 (Div2, onsite) B 吃豆豆 ②树形dp...
2019 Wannafly summer camp Day2
weixin_38169886的博客
08-04 159
Day2 还是很有难度的emmmm A - Por Costel and Azerah 给定n个数，从其中取出若干个数使其和为偶数，问有多少种取法 （1）dp做法：挖坑待更 （2）数学做法：可以分为三种情况： 　　　　　　　　1，从奇数中取2*x个 s1=C(n,2)+C(n,4)+...+C(n,n/2*2) 　　　　　　　　2，从偶数中取任意个s2=C(n,1)+C(n,...
微信Java开发工具包，支持包括微信支付、开放平台、公众号、企业微信、视频号、小程序等微信功能模块的后端开发
11-15
微信Java开发工具包，支持包括微信支付、开放平台、公众号、企业微信、视频号、小程序等微信功能模块的后端开发。
如何制作MC（需要下载海龟编辑器2.0，下载pyglet==1.5.15）
11-15
如何制作MC（需要下载海龟编辑器2.0，下载pyglet==1.5.15）
民宿预订管理系统 SSM毕业设计 附带论文.zip
11-15
民宿预订管理系统 SSM毕业设计 附带论文 启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B
matlab常微分方程和常微分方程组的求解.docx
最新发布
11-15
内容概要：本文详细介绍了如何利用MATLAB解决各种类型的常微分方程（组），包括解析解和数值解的方法，并给出了具体的实例以及求解步骤。重点探讨了dsolve()函数的使用来获取方程的符号解，以及各类Solver命令如ode45、ode23等用于求数值解的特点与适用情况。 适合人群：高校理工科专业学生、科研工作者，尤其对数学建模感兴趣的研究人士。 使用场景及目标：帮助用户理解和应用MATLAB解决实际工程和科学研究中的微分方程问题，提升问题解决效率。 其他说明：除了理论介绍外，文档还提供了多个实际案例及其相应的MATLAB脚本供参考和练习，有助于加深理解和提高动手能力。
qwen2.5 + langchain pip依赖包
11-15
qwen2.5 + langchain pip依赖包
SeeJoPlayer视频播放器.zip
11-15
SeeJoPlayer视频播放器
2017-CCPC-FINAL
10-04
2017-CCPC-FINAL是指2017年CCPC全国大学生程序设计竞赛的决赛。决赛于2017年12月3日举行，涉及多个问题，包括问题A：狗和笼子，问题G：Alice的邮票和问题H：等距离等。在问题A中，Jerry有N只狗和N个笼子，他需要将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值