Solved Pro.ID Title Ratio(Accepted / Submitted)
  1001 Rikka with Quicksort 25.85%(38/147)
  1002 Rikka with Cake 31.69%(379/1196)
  1003 Rikka with Mista 5.57%(45/808)
  1004 Rikka with Geometric Sequence 9.52%(2/21)
  1005 Rikka with Game 35.29%(866/2454)
  1006 Rikka with Coin 7.16%(358/5003)
  1007 Rikka with Travels 21.46%(85/396)
  1008 Rikka with Stable Marriage       字典树+贪心 17.02%(8/47)
  1009 Rikka with Traffic Light 0.00%(0/24)
  1010 Rikka with Defensive Line 0.00%(0/20)
  1011 Rikka with Segment Tree 39.39%(13/33)

1007 Rikka with Travels

思路：

一棵树上最长链处理，分出两种情况，一种是（a,b）各占一个端点，还有一种情况a占整条链，b是全踩在非最长链。

#include <algorithm>

#include  <iterator>

#include  <iostream>

#include   <cstring>

#include   <cstdlib>

#include   <iomanip>

#include    <bitset>

#include    <cctype>

#include    <cstdio>

#include    <string>

#include    <vector>

#include     <stack>

#include     <cmath>

#include     <queue>

#include      <list>

#include       <map>

#include       <set>

#include   <cassert>

#include <unordered_map>

// #include<bits/extc++.h>

// using namespace __gnu_pbds;

using namespace std;

#define pb push_back

#define fi first

#define se second

#define debug(x) cerr<<#x << " := " << x << endl;

#define bug cerr<<"-----------------------"<<endl;

#define FOR(a, b, c) for(int a = b; a <= c; ++ a)

typedef long long ll;

typedef unsigned long long ull;

typedef long double ld;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int inf = 0x3f3f3f3f;

const ll inff = 0x3f3f3f3f3f3f3f3f;

const int mod = ;

template<typename T>

inline T read(T&x){

    x=;int f=;char ch=getchar();

    while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();

    while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

    return x=f?-x:x;

}

/**********showtime************/

            const int maxn = 1e5+;

            int n;

            vector<int>mp[maxn];

            int vis[maxn];

            int dis[maxn];

            vector<int>lian;

            ///扣出最长链

            void koulian() {

                for(int i=; i<=n; i++) dis[i] = inf;

                dis[] = ;

                queue<int>que;  que.push();

                int t = ;

                while(!que.empty()) {

                    int u = que.front(); que.pop();

                    if(dis[u] > dis[t])t = u;

                    for(int v : mp[u]) {

                        if(dis[v] > dis[u] + ) {

                            dis[v] = dis[u] + ;

                            que.push(v);

                        }

                    }

                }

                for(int i=; i<=n; i++) dis[i] = inf;

                dis[t] = ;

                que.push(t);

                int s = t;

                while(!que.empty()) {

                    int u = que.front(); que.pop();

                    if(dis[u] > dis[s])s = u;

                    for(int v:mp[u]) {

                        if(dis[v] > dis[u] + ) {

                            dis[v] = dis[u] + ;

                            que.push(v);

                        }

                    }

                }

                lian.pb(s);

                vis[s] = ;

                while(s != t) {

                    for(int v : mp[s]) {

                        if(dis[v] + == dis[s]) {

                            s = v;

                            lian.pb(s);

                            vis[s] = ;

                            break;

                        }

                    }

                }

            }

            int dpa[maxn], dpb[maxn][], pre[maxn];

            int dppre[maxn], dpback[maxn];

            ///求出以最长链上一个点为根节点的不经过最长链的最大深度

            void dfs1(int u, int fa) {

                dpa[u] = ;

                for(int v : mp[u]) {

                    if(v == fa || vis[v]) continue;

                    dfs1(v, u);

                    dpa[u] = max(dpa[u], dpa[v] + );

                }}

            void dfs2(int u, int fa) {

                dpb[u][] = dpb[u][] = ;

                ///dpb[0]表示包含根节点的最长链

                ///dpb[1]表示包含根节点的次长链

                pre[u] = ;

                for(int v : mp[u]) {

                    if(vis[v] || v == fa) continue;

                    dfs2(v, u);

                    pre[u] = max(pre[u], pre[v]);

                    if(dpb[u][] <= dpb[v][] + ){

                        dpb[u][] = dpb[v][] + ;

                        if(dpb[u][] < dpb[u][]) {

                            swap(dpb[u][], dpb[u][]);

                        }

                    }

                }

                pre[u] = max(pre[u], dpb[u][] + dpb[u][] - );

            }

            int hei[maxn];

int main(){

            int T;  scanf("%d", &T);

            while(T--){

                scanf("%d", &n);

                for(int i=; i<n; i++) {

                    int u, v;

                    scanf("%d%d", &u, &v);

                    mp[u].pb(v);

                    mp[v].pb(u);

                }

                for(int i=; i<=n; i++) vis[i] = , hei[i] = , pre[i] = , dppre[i] = ,dpback[i] = ;

                koulian();

                for(int i=; i<lian.size(); i++) {

                    int v = lian[i];

                    dfs1(v, v);

                    if(i)dppre[i] =  max(dppre[i-], dpa[v] + i);

                    else dppre[i] = dpa[v];

                    for(int p : mp[v]) {

                        if(vis[p]) continue;

                        dfs2(p, p);

                        pre[v] = max(pre[v], pre[p]);

                    }

                    pre[v] = max(pre[v], pre[lian[max(, i-)]]);

                }

                int cc = ;

                for(int i=lian.size()-; i>=; i--) {

                    if(i == lian.size() - ) dpback[i] = dpa[lian[i]];

                    else dpback[i] = max(dpback[i+], dpa[lian[i]] + cc);

                    cc++;

                }

                int all = lian.size();

                hei[all] = pre[lian[all-]];

                hei[pre[lian[all-]]] = all;

                for(int i=lian.size() - ; i>=; i--) {

                    int v = lian[i];

                    int a = dppre[i-];

                    int b = dpback[i];

                    hei[a] = max(hei[a], b);

                    hei[b] = max(hei[b], a);

                }

                ll sum = ;

                int c = ;

                for(int i=all; i>=; i--) {

                    c = max(c, hei[i]);

                    sum = sum + c;

                }

                printf("%lld\n", sum);

                lian.clear();

                for(int i=; i<=n; i++) mp[i].clear();

            }

            return ;

}

/*

10

9

1 2

2 3

3 4

4 5

5 8

3 6

3 7

7 9

14

1 2

2 3

3 4

4 5

5 6

6 7

3 8

3 9

4 10

4 11

11 14

5 12

5 13

 = 36

*/

1008 Rikka with Stable Marriage

思路：

就是字典树+贪心，和第五场那个贪心顺序反一下就行了

// #pragma GCC optimize(2)

// #pragma GCC optimize(3)

// #pragma GCC optimize(4)

#include <algorithm>

#include  <iterator>

#include  <iostream>

#include   <cstring>

#include   <cstdlib>

#include   <iomanip>

#include    <bitset>

#include    <cctype>

#include    <cstdio>

#include    <string>

#include    <vector>

#include     <stack>

#include     <cmath>

#include     <queue>

#include      <list>

#include       <map>

#include       <set>

#include   <cassert>

// #include<bits/extc++.h>

// using namespace __gnu_pbds;

using namespace std;

#define pb push_back

#define fi first

#define se second

#define debug(x) cerr<<#x << " := " << x << endl;

#define bug cerr<<"-----------------------"<<endl;

#define FOR(a, b, c) for(int a = b; a <= c; ++ a)

typedef long long ll;

typedef long double ld;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int inf = 0x3f3f3f3f;

const ll inff = 0x3f3f3f3f3f3f3f3f;

const int mod = ;

template<typename T>

inline T read(T&x){

    x=;int f=;char ch=getchar();

    while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();

    while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

    return x=f?-x:x;

}

/**********showtime************/

            const int maxn = 1e5+;

            int a[maxn],b[maxn];

            int tot[],rt[];

            int bz[];

            struct node{

                int ch[];

                int fa;

                int sz;

                void init(int f) {

                    ch[] = ch[] = ;

                    fa = f;

                    sz = ;

                }

            }tree[][maxn * ];

            int shu[];

            void add(int p, int len, int flag) {

                if(len == ){

                    tree[flag][p].sz++;

                    return;

                }

                if(tree[flag][p].ch[shu[len]] == )

                {

                    tree[flag][p].ch[shu[len]] = ++ tot[flag];

                    tree[flag][tot[flag]].init(p);

                }

                int nx = tree[flag][p].ch[shu[len]];

                add(nx, len-, flag);

                int lc = tree[flag][p].ch[];

                int rc = tree[flag][p].ch[];

                tree[flag][p].sz = tree[flag][lc].sz + tree[flag][rc].sz;

            }

            void insert(int val, int flag) {

                int len = ;

                for(int i=; i<=; i++) shu[++len] = val % , val /= ;

                add(rt[flag], , flag);

            }

            void display(int rt, int flag) {

                if(rt == ) return ;

//                cout<<tree[flag][rt].sz<<endl;

                display(tree[flag][rt].ch[], flag);

                display(tree[flag][rt].ch[], flag);

            }

            vector<int>vec;

            void find(int a, int b, int cen, int val) {

                if(cen == ) {

                    vec.pb(val);

                    tree[][a].sz--;

                    tree[][b].sz--;

                    return;

                }

                if(tree[][tree[][a].ch[]].sz && tree[][ tree[][b].ch[]].sz){

                    find(tree[][a].ch[], tree[][b].ch[], cen-, val + bz[cen-]);

                }

                else if(tree[][tree[][a].ch[]].sz && tree[][ tree[][b].ch[]].sz){

                    find(tree[][a].ch[], tree[][b].ch[], cen-, val + bz[cen-]);

                }

                else if(tree[][ tree[][a].ch[] ].sz && tree[][ tree[][b].ch[]].sz ) {

                    find(tree[][a].ch[], tree[][b].ch[], cen-, val);

                }

                else if(tree[][ tree[][a].ch[] ].sz && tree[][ tree[][b].ch[]].sz) {

                    find(tree[][a].ch[], tree[][b].ch[], cen-, val);

                }

                tree[][a].sz = tree[][tree[][a].ch[]].sz + tree[][tree[][a].ch[]].sz;

                tree[][b].sz = tree[][tree[][b].ch[]].sz + tree[][tree[][b].ch[]].sz;

            }

int main(){

            int T;  scanf("%d", &T);

            bz[] = ;

            for(int i=; i<=; i++) bz[i] =  * bz[i-];

            while(T--) {

                tot[] = tot[] = ;

                rt[] = ++tot[];

                tree[][rt[]].init();

                rt[] = ++tot[];

                tree[][rt[]].init();

                int n;  scanf("%d", &n);

                for(int i=; i<=n; i++) scanf("%d", &a[i]), insert(a[i], );

                for(int i=; i<=n; i++) scanf("%d", &b[i]), insert(b[i], );

                vec.clear();

                for(int i=; i<=n; i++) {

                    find(rt[], rt[], , );

                }

                ll sum = ;

                for(int i=; i<vec.size(); i++) sum += vec[i];

                printf("%lld\n", sum);

            }

            return ;

}

2019dx#9的更多相关文章

  1. 2019DX#10

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 Minimum Spanning Trees 22.22%(2/9)   1002 Lin ...

  2. 2019DX#8

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 Acesrc and Cube Hypernet 7.32%(3/41)   1002 A ...

  3. 2019dx#7

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 A + B = C 10.48%(301/2872)   1002 Bracket Seq ...

  4. 2019DX#6

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 Salty Fish 16.28%(7/43)  OK 1002 Nonsense Tim ...

  5. 2019DX#5

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 fraction 辗转相除 4.17%(7/168) ok  1002 three arr ...

  6. 2019dx#4

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 AND Minimum Spanning Tree 31.75%(1018/3206)   ...

  7. 2019DX#3

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 Azshara's deep sea 凸包 6.67%(6/90)  

  8. 2019DX#2

    Solved Pro.ID Title Ratio(Accepted / Submitted)   1001 Another Chess Problem 8.33%(1/12)   1002 Beau ...

  9. 2019DX#1

    1001 Blank 题意 有一个长度为n(n<=100)的位子,填入四种颜色,有m个限制,某个区间的颜色个数要恰好等于x个.问颜色个数的方案数. 思路 DP 四维的DP,利用滚动数组优化一维空 ...

随机推荐

  1. sort+结构体+简单数学+暴力-例题

    A-前m大的数 还记得Gardon给小希布置的那个作业么?(上次比赛的1005)其实小希已经找回了原来的那张数表,现在她想确认一下她的答案是否正确,但是整个的答案是很庞大的表,小希只想让你把答案中最大 ...

  2. 基于SpringBoot从零构建博客网站 - 新增创建、修改、删除专栏功能

    守望博客是支持创建专栏的功能,即可以将一系列相关的文章归档到专栏中,方便用户管理和查阅文章.这里主要讲解专栏的创建.修改和删除功能,至于专栏还涉及其它的功能,例如关注专栏等后续会穿插着介绍. 1.创建 ...

  3. 关于JS、JQ首行首列固定展示

    当时遇见这个问题 是医院手麻系统大批量数据展示,由于是旧项目系统没有使用到前端的架构 只能使用JQ,JS, css完成 也谢谢给予我支持的同行们 固定首行数据: 采用函数的方式进行  JQ /** * ...

  4. Jenkins安装插件问题

    最近在电脑尝试安装Jenkins软件 安装插件的时候 一直报错 没有推荐插件提示一直报错 at java.lang.Thread.run(Unknown Source) Caused by: java ...

  5. spark shuffle写操作三部曲之BypassMergeSortShuffleWriter

    前言 再上一篇文章 spark shuffle的写操作之准备工作 中,主要介绍了 spark shuffle的准备工作,本篇文章主要介绍spark shuffle使用BypassMergeSortSh ...

  6. JDK1.8源码分析01之学习建议（可以延伸其他源码学习）

    序言:目前有个计划就是准备看一下源码,来提升自己的技术实力.同时现在好多面试官都喜欢问源码,问你是否读过JDK源码等等? 针对如何阅读源码,也请教了我的老师.下面就先来看看老师的回答,也许会有帮助呢. ...

  7. eclipse导入码云-GIT项目

    1.首先找到项目源码地址我随便找到一个git地址 :https://gitee.com/mingSoft/MCMS 2.打开eclipse空白处右键导入项目搜索git. 3.将第一步复制的git地址复 ...

  8. Linux curl 表单登录或提交与cookie使用

    本文主要讲解通过curl 实现表单提交登录.单独的表单提交与表单登录都差不多,因此就不单独说了. 说明:针对curl表单提交实现登录,不是所有网站都适用,原因是有些网站后台做了限制或有其他校验.我们不 ...

  9. 消息中间件-activemq安全机制

    activemq作为消息中间件这样一个独立的个体存在,连通用户和服务器.如果没有一套完备的安全机制去设置用户权限设置消息分发机制可想后果是非常严重.ActiveMQ如果不加入安全机制的话,任何人只要知 ...

  10. 使用ArrayPool池化大型数组（翻译）

    原文链接:https://adamsitnik.com/Array-Pool/ 使用ArrayPool 简介 .NET的垃圾收集器(GC)实现了许多性能优化,其中之一就是,设定年轻的对象很快消亡,然而 ...