LOJ刷题记录：2012-2017(SCOI2016)

最新推荐文章于 2022-01-26 00:33:53 发布
最新推荐文章于 2022-01-26 00:33:53 发布
阅读量675 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OIljt12138/article/details/77019082
版权

LOJ刷题记录：2012-2017(SCOI2016)

loj#2012. 「SCOI2016」背单词

神贪心…

所有串翻转，考虑建一棵这样的树， i→j 当且仅当 si 是 sj 最长的前缀。这棵树可以用trie建出来。第一种方案显然不会采纳，因此每一个元素放完后，才能放他的子树，而且要按照从子树大小由小到大的放…

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

const int MAXN = 600005;
int chl[MAXN][26], top = 0, root = 0;
int fin[MAXN];
void push(int &nd, const char *str)
{
    if (!nd) nd = ++top;
    if (*str == '\0') fin[nd] = 1;
    else push(chl[nd][*str-'a'], str+1);
}
int n;
char str[MAXN];
vector<int> v[MAXN];
int siz[MAXN];
int dfn[MAXN], dfn_top = 0;
long long ans = 0;

void dfs_build(int nd, int last)
{
    if (last && fin[nd]) v[last].push_back(nd), last = nd;
    if (!last) last = nd;
    for (int i = 0; i < 26; i++)
        if (chl[nd][i])
            dfs_build(chl[nd][i], last);
}

void dfs_siz(int nd)
{
    siz[nd] = 1;
    for (auto i : v[nd]) {
        dfs_siz(i);
        siz[nd] += siz[i];
    }
}

bool cmp(int i, int j)
{ return siz[i] < siz[j]; }
void calc(int nd, int f)
{
    dfn[nd] = ++dfn_top;
    if (nd != root) ans += dfn[nd]-dfn[f];
    sort(v[nd].begin(), v[nd].end(), cmp); 
    for (auto i : v[nd])
        calc(i, nd);
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%s", str);
        int L = strlen(str);
        reverse(str, str+L);
        push(root, str);
    }
    fin[root] = 1;
    dfs_build(root, 0);
    dfs_siz(root);
    calc(root, 0);
    printf("%lld\n", ans);
    return 0;
}

loj#2013. 「SCOI2016」幸运数字

小清新数据结构~

原来是用的树剖-线性基三个 log 不科学做法，现在又写了一个点分治-线性基两个 log ，果然跑的比谁都快。

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

const int MAXN = 20005, MAXQ = 200005;

struct linear_base {
    long long k[70];
    int top = 0;
    inline void clear()
    { top = 0; }
    void push(long long x)
    {
        for (int i = 1; i <= top; i++)
            if ((x^k[i]) < x)
                x ^= k[i];
        if (!x) return;
        for (int i = 1; i <= top; i++)
            if ((x^k[i]) < k[i])
                k[i] ^= x;
        k[++top] = x;
        for (int i = top; i > 1 && k[i] > k[i-1]; i--)
            swap(k[i], k[i-1]);
    }
    long long get_max()
    {
        long long ans = 0;
        for (int i = 1; i <= top; i++)
            if ((ans^k[i])>ans)
                ans ^= k[i];
        return ans;
    }
    friend linear_base operator + (const linear_base &a, long long b)
    {
        linear_base c = a;
        c.push(b);
        return c;
    }
    friend linear_base operator + (const linear_base &a, const linear_base &b)
    {
        linear_base c = a;
        for (int i = 1; i <= b.top; i++)
            c.push(b.k[i]);
        return c;
    }
};

struct node {
    int to, next;
} edge[MAXN*2];
int head[MAXN], top = 0;
void push(int i, int j)
{ edge[++top] = (node) {j, head[i]}, head[i] = top; }

int vis[MAXN], siz[MAXN], col[MAXN];
long long ans[MAXN*10];
long long d[MAXN];
linear_base lb[MAXN];
int n, q;

void dfs_siz(int nd, int f)
{
    siz[nd] = 1;
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to == f || vis[to]) continue;
        dfs_siz(to, nd), siz[nd] += siz[to];
    }
}

void dfs_find_center(int nd, int f, const int totsiz, int &ans, int &max_siz)
{
    int cnt = (f!=0)*(totsiz-siz[nd]);
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to == f || vis[to]) continue;
        dfs_find_center(to, nd, totsiz, ans, max_siz);
        cnt = max(cnt, siz[to]);
    }
    if (cnt < max_siz) ans = nd, max_siz = cnt;
}

void dfs_paint(int nd, int f, int c)
{
    col[nd] = c;
        lb[nd] = lb[f]+d[nd];
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to == f || vis[to]) continue;
        dfs_paint(to, nd, c);
    }
}

vector<pair<int, int> > qy[MAXN];

int tp = 0;
int tmp = 0;

void dfs_calc(int nd, int f)
{
    for (auto i : qy[nd]) 
        if (col[i.first] > tmp && col[i.first] < col[nd]) 
            ans[i.second] = (lb[i.first]+lb[nd]).get_max();
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to == f || vis[to]) continue;
        dfs_calc(to, nd);
    }
}

void calc(int nd)
{
    dfs_siz(nd, 0);
    int center = nd, tt = INT_MAX;
    dfs_find_center(nd, 0, siz[nd], center, tt), vis[center] = 1;
        tmp = tp;
    lb[center].clear(), lb[center].push(d[center]);
    // cerr << center << endl;
    for (int i = head[center]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (vis[to]) continue;
        dfs_paint(to, center, ++tp);
    }
    for (auto i : qy[center]) 
        if (col[i.first] > tmp) {
            ans[i.second] = lb[i.first].get_max();
        }
    for (int i = head[center]; i; i = edge[i].next) {
        int to = edge[i].to;
        dfs_calc(to, center);
    }
    for (int i = head[center]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (!vis[to]) calc(to);
    }
}


int main()
{
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++) scanf("%lld", &d[i]);
    for (int i = 1; i < n; i++) {
        int u, v; scanf("%d%d", &u, &v);
        push(u, v), push(v, u);
    }
    for (int i = 1; i <= q; i++) {
        int x, y; scanf("%d%d", &x, &y);
        if (x == y) ans[i] = d[x];
        else qy[x].push_back(make_pair(y, i)), qy[y].push_back(make_pair(x, i));
    }
    calc(1);
    for (int i = 1; i <= q; i++)
        printf("%lld\n", ans[i]);
    return 0;
}

loj#2014. 「SCOI2016」萌萌哒

真-神数据结构系列…..

和花神游历各国是一类题…本质有用的操作只有很少（这道题是 O(n) 的），但有很多的无效操作，关键在于如何将无效操作最小化。

这个题的方法是你用ST表的思路，将 l,r 拆成二的整次幂，用 f[n][i] 为 n 开始i个人的一个大点。同层只和同层的连边，表示是否整个都连接上了。对于每一次操作，如果同层已经连过边了，那么退出；否则说明还有空位置，这样在同层连边，并递归的连儿子。由于一共只有 n 个有用操作，每次有用操作的代价是O(lgn)次并查集操作，无用操作不会超过 O(nlgn) 个，总复杂度是 O(nlgn) 的。如果用标记实现常数会优越一点。

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

const int MAXN = 100005;
int n, q;
pair<int,int> f[MAXN][20];
pair<int,int> findf(const pair<int,int> &pr)
{ return f[pr.first][pr.second]!=pr?f[pr.first][pr.second]=findf(f[pr.first][pr.second]):pr; }

const int mod = 1e9+7;

void link(const pair<int,int> &a, const pair<int,int> &b)
{
    // cerr << a.first << " " << a.second << "," << b.first << " " << b.second << endl;
    pair<int,int> fa = findf(a), fb = findf(b);
    if (fa == fb) return;
    f[fa.first][fa.second] = fb;
    if (a.second != 0) {
        link(make_pair(a.first, a.second-1), make_pair(b.first, b.second-1));
        link(make_pair(a.first+(1<<(a.second-1)), a.second-1), make_pair(b.first+(1<<(b.second-1)), b.second-1));
    }
}

int main()
{
    scanf("%d%d", &n, &q);
    int l1, l2, r1, r2;
    for (int i = 1; i <= n; i++)
        for (int j = 0; j < 20; j++)
            f[i][j] = make_pair(i, j);
    for (int i = 1; i <= q; i++) {
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        int d = r1-l1+1;
        for (register int j = 0; j < 20; j++)
            if (d&(1<<j)) {
                link(make_pair(l1, j), make_pair(l2, j));
                l1 += (1<<j), l2 += (1<<j);
            }
    }
    int ans = 1;
    for (int i = 1; i <= n; i++)
        if (f[i][0] == make_pair(i, 0)) {
            if (findf(make_pair(1, 0)) == f[i][0]) ans = (long long)ans*9%mod;
            else ans = (long long)ans*10%mod;
        }
    printf("%d\n", ans);
    return 0;
}

loj#2015. 「SCOI2016」妖怪

一眼题…设 a/b=λ ，先二分个答案，然后发现每一个妖怪 λ 可行取值都在一个区间内，就做了。

但是这样会被卡时间…然后发现有几个数据都是递增的，可能到最后才能发现冲突…random_shullfe了一下就过了…以后要养成random_shuffle的好习惯…

大家貌似是三分的…?按照codeforces那个题的经验三分可能有点问题吧..

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

const int MAXN = 1000005;
int n;

struct p {
    double a, b;
    friend bool operator < (const p &a, const p &b)
    { return a.a<b.a||(a.a==b.a&&a.b<b.b); }
} pt[MAXN];
double L = 0, R = 1e10;

bool judge(double k)
{
    L = 0, R = 1e10;
    register double w, dt;
    for (register int i = 1; i <= n; i++) {
        w = k-pt[i].a-pt[i].b, dt = sqrt(w*w-4*pt[i].a*pt[i].b);
        L = max((w-dt)/(2*pt[i].b), L), R = min((w+dt)/(2*pt[i].b), R);
        if (L >= R) return 0;
    }
    return 1;
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%lf%lf", &pt[i].a, &pt[i].b);
    //sort(pt+1, pt+n+1);
    srand(time(0));
    random_shuffle(pt+1, pt+n+1);
    double l = 0, r = 1.5e8, mid;
    for (int i = 1; i <= n; i++)
        l = max(l, pt[i].a+pt[i].b+2*sqrt(pt[i].a*pt[i].b));
        while (r-l >= 1e-6) {
        mid = (l+r)/2;
        if (judge(mid)) r = mid;
        else l = mid;
    }
    printf("%.4f\n", l);
    return 0;
}

loj#2016. 「SCOI2016」美味

新套路get√…

其实那个异或只不过是改变了每一位0/1的优先级而已..所以按照新的优先级二分（其实就是逐位确定）然后用主席树统计一下答案…

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

const int MAXN = 200005;

int n, m;
int a[MAXN];

int sum[MAXN*40], l[MAXN*40], r[MAXN*40], lc[MAXN*40], rc[MAXN*40], top = 0, root[MAXN];

void build(int &nd, int opl, int opr)
{
    nd = ++top, l[nd] = opl, r[nd] = opr;
    if (opl < opr) build(lc[nd], opl, (opl+opr)/2), build(rc[nd], (opl+opr)/2+1, opr);
}

void modify(int pre, int &nd, int pos, int dt)
{
    nd = ++top, l[nd] = l[pre], r[nd] = r[pre], sum[nd] = sum[pre]+dt;
    if (l[nd] < r[nd]) {
        int mid = (l[nd]+r[nd])/2;
        if (pos <= mid) rc[nd] = rc[pre], modify(lc[pre], lc[nd], pos, dt);
        else lc[nd] = lc[pre], modify(rc[pre], rc[nd], pos, dt);
    }
}

int query(int nd, int opl, int opr)
{
    // cerr << opl << " " << opr << " " << l[nd] << " " << r[nd] << endl;
    if (opl > opr) return 0;
    if (l[nd] == opl && r[nd] == opr) return sum[nd];
    else {
        int mid = (l[nd]+r[nd])/2;
        if (opr <= mid) return query(lc[nd], opl, opr);
        else if (opl > mid) return query(rc[nd], opl, opr);
        else return query(lc[nd], opl, mid)+query(rc[nd], mid+1, opr);
    }
}

int query_sum(int L, int R, int opl, int opr)
{
    // cerr << opl << " " << opr << endl;
    return query(root[R], opl, opr)-query(root[L-1], opl, opr);
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    build(root[0], 1, n);
    for (int i = 1; i <= n; i++) modify(root[i-1], root[i], a[i], 1);
    cerr << query_sum(1, 3, 2, 4) << endl;
    for (int i = 1; i <= m; i++) {
        int b, x, opl, opr, cur = 0;
        scanf("%d%d%d%d", &b, &x, &opl, &opr);
        for (int j = 20; j >= 0; j--) {
            int pos = ((b&(1<<j))==0);
            if (query_sum(opl, opr, max(1, (cur|(pos<<j))-x), min((cur|(pos<<j)|((1<<j)-1))-x, n)) > 0) {
                cur |= pos<<j;
            } else cur |= (!pos)<<j;
        }
        printf("%d\n", cur^b);
    }
    return 0;
}

loj#2017. 「SCOI2016」围棋

轮廓线dp….坑待填

OIljt12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[SCOI2016]背单词
蒟蒻QMQ
10-26 246
题目 题目 做法 我们把每个单词反过来，然后如果st[i]st[i]st[i]是st[j]st[j]st[j]的前缀，且不存在st[k]st[k]st[k]是st[j]st[j]st[j]的前缀，且st[i]st[i]st[i]是st[k]st[k]st[k]的前缀，那么iii是jjj的父亲，显然这样构造不存在环，且是一个森林。（构造方法字典树） 不难发现，如果你每个点都等着祖先拿完再拿（拿就是背下来的意思），那么价值都是≤nnn的，总的价值小于等于n2n^2n2，也就是说第一条规则就是废的，一个点一定得在
[SCOI2016]萌萌哒（并查集+反向ST表）
蒟蒻QMQ
10-28 170
题意 题目 做法 先说普通O(n2)O(n^2)O(n2)做法。 就是把相同的数字暴力合并，然后计算联通块个数cntcntcnt，然后答案就是10cnt−1∗910^{cnt-1}*910cnt−1∗9。 但是呢，这样合并太太太太慢了，比如说[l,r][l,r][l,r]这个区间等于[q,p][q,p][q,p]，然后[l,r][l,r][l,r]又等于[q+p2,?][\frac{q+p}{2},?][2q+p​,?]，这样子的话，我们会跑2(r−l+1)2(r-l+1)2(r−l+1)，但事实上，我们会
P3295 [SCOI2016]萌萌哒（DP+倍增）
07-18 173
又不是只有女孩子才能萌萌哒，啾咪
[SCOI2016]幸运数字 树链剖分，线性基
weixin_30845171的博客
02-14 57
[SCOI2016]幸运数字 LG传送门 为了快乐，我们用树剖写这题。 强行树剖，线段树上每个结点维护一个线性基，每次查询暴力合并。 瞎分析一波复杂度：树剖两点之间\(\log n\)条重链，每条重链在线段树上最多合并\(\log n\)次，合并两个线性基最多需要\(\log m\)次插入，每次插入\(\log m\)（设\(m\)为值域）。总复杂度大概是\(O(n (\log n) ^ 2 (\...
【SCOI2016】背单词
Brute♂force
04-12 699
题目 题目描述 Lweb 面对如山的英语单词，陷入了深深的沉思，”我怎么样才能快点学完，然后去玩三国杀呢？“。这时候睿智的凤老师从远处飘来，他送给了 Lweb 一本计划册和一大缸泡椒，他的计划册是长这样的： —————序号 单词————— 1 2…n-2n-1 n————— 然后凤老师告诉 Lweb ，我知道你要学习的单词总共有 n 个，现在我们从上往下完成计划表，对于一个序号为 x 的单词（序号...
Loj X:创建逻辑电路-开源
07-04
Loj X 使创建真正的计算单元甚至小型完整处理器成为可能。 除了逻辑门，存储盒和程序阅读器可以集成到电路中。
oi_code:做题记录
04-18
的做题记录 Updates: 2021.04.18 2021.04.17 2021.04.15 2021.04.14 2021.04.13 2021.04.12 2021.04.08 2021.04.07 Luogu4178 Luogu3241 2021.04.06 Luogu3769 Luogu5043 2021.04.05 Luogu4148 Luogu3273 2021....
OJ系统汇总-2021-10-6(C)-32页.pdf
10-06
* LOJ：是一个提供了大量的算法和数据结构的题目的OJ系统。 * HustOJ：是一个提供了大量的算法和数据结构的题目的OJ系统。 * 牛客竞赛网：是一个提供了大量的算法和数据结构的题目的OJ系统。 * 计蒜客：是一个提供了...
up_717085_google-api-php-client_71loj.rar
12-22
另一个文件"fileinfo.txt"可能是一个文件信息记录，它可能包含了关于压缩包内各个文件的详细信息，如文件类型、大小、创建日期等。在开发过程中，这样的文件可以帮助开发者追踪代码的变化或了解文件的来源。 在学习...
scicloj.github.com：Scicloj网站
02-08
scicloj.github.com：Scicloj网站
[SCOI2016]幸运数字
m0_51547083的博客
01-26 124
树剖+线性基，倍增+线性基
【SCOI2016】背单词(tire+贪心+缩点
我们仍未知道那天所看见的花的名字。
09-05 685
#include<bits/stdc++.h> using namespace std; #define int long long const int N=5e5+10; string s[N]; int n,t[N][30],tot=0,vis[N],K[N];int sz[N]; struct edge{ int to,nxt; }d[N];int head[N],Cnt=1; void add(int u,int v){ d[++Cnt]=(edge){v,head[u]},head[
【LOJ #2017】「SCOI2016」围棋—（轮廓线dp+KMP）
Stargazer的博客
10-19 149
传送门 考虑计算完全没有的情况减去 令f[i][j][sta][k][p]f[i][j][sta][k][p]f[i][j][sta][k][p] 表示到i,ji,ji,j当前这行和上面一行与模式串第一行匹配的状态为stastasta 上一行和第一行模式串匹配到了kkk，第二行匹配到了jjj stastasta是由于上面一行和当前这行总共有用的位置只有m−c+1m-c+1m−c+1个 所以用轮廓线...
SCOI2017 真滚粗记
QWsin的博客
04-09 2499
我也不知道为啥现在还有心情写滚粗记。。
4572: [Scoi2016]围棋
CRZbulabula的博客
12-24 907
4572: [Scoi2016]围棋 Time Limit: 50 Sec  Memory Limit: 512 MB Submit: 108  Solved: 60 [Submit][Status][Discuss] Description 近日，谷歌研发的围棋AI—AlphaGo以4:1的比分战胜了曾经的世界冠军李世石，这是人工智能领域的又一里程碑。 与传统的搜索式AI不同，A
SCOI2017 赛后总结及反思
Lannister_Stark的博客
04-12 1458
SCOI2017 赛后总结及反思前言前不久才去打了校赛，现在是参加省选，时间变了，经历变了，但是地点没变，仍然是那栋熟悉的实验大楼。我也没变，还是一如既往的弱，一如既往的水。比赛历程D1T1树链剖分裸题，然而我是在省选后的那个周一学的树链剖分，于是0分。 D1T2强力DFS，然而考场上写挂了。 D1T3计算几何，感觉自己还是时间分配不当，花了大量时间来优化30%，结果悲催的拖累了T2……D2T1
SCOI-2017 游记 SCOI-2017 酱油记 SCOI-2017 没有滚粗资格的记
Lazer2001
04-13 1289
大家都很强， 可与之共勉。感觉这一次对于我这种高一的蒟蒻，极限就是260分啊。Day1 T1 100， T3 30； Day2 T1 100， T2 30。我也不知道为什么Day2 T1这种签到题只有60分。Day1 T1自己YY出了长链剖分+贪心。40行做出来了还比较骄傲呢，结果T3的暴力写不出来。最后没事打了两局MaJiang。 Day2 T1觉得简单就DP了一下概率值，以为找最长路就是SPF
【LOJ】#2012. 「SCOI2016」背单词
weixin_30709061的博客
06-08 115
题解 我们发现第一种操作肯定不可取，每个节点里它最近的点是它最长出现过的后缀，发现这就是AC自动机的fail节点，根据fail的关系这会是一棵树，而一个单词的前一个序号最大的后缀必定是它的父亲 然后我们考虑怎么获得最小值，x是肯定要加上的，我们让每次减掉的y最小 一个错误的想法：按照儿子个数分类，建一个set，每次拿儿子最小的= = emmm这个，如果你有一条10^3的链和1个点5个儿子...
LOJ-6279-数列分块入门3(分块, 二分)
最新发布
05-24
题目描述 给定一个长度为n的序列a，有m次询问。每次询问给定l, r, k，要求区间[l, r]中第k小的数。 输入格式 第一行两个整数n,m。 接下来一行n个整数，表示序列a。 接下来m行，每行三个整数l,r,k。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值