2020CCPC长春站 A,D,F,J,K,L

最新推荐文章于 2021-05-25 00:06:56 发布
最新推荐文章于 2021-05-25 00:06:56 发布
阅读量1.6k 收藏
点赞数 5
文章标签： 算法 线性规划 tag xmpp instance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44491423/article/details/109783141
版权

文章目录

A. Krypton

二进制枚举所有情况，找最大的即可。

#include <bits/stdc++.h>
using namespace std;
int n;
int cost[7]={1,6,28,88,198,328,648};
int extra[7]={8,18,28,58,128,198,388};
int normal[7]={10,60,280,880,1980,3280,6480};
int main()
{
    scanf("%d",&n);
    int ans=0;
    for(int i=0;i<(1<<7);++i)
    {
        int tmp=n;
        int res=0;
        int now=i;
        for(int j=0;j<7;++j)
        {
            if(now&1)
            {
                tmp-=cost[j];
                res+=extra[j]+normal[j];
            }
            now>>=1;
        }
        if(tmp<0)
        continue;
        ans=max(ans,res+tmp*10);
    }
    printf("%d\n",ans);
    return 0;
}

D. Meaningless Sequence

我们发现，ai=(ci的二进制下1的个数)。对于求和，我们只要找到对于包含i个1的情况有多少种即可，这是个组合数学问题。我们从最高位的1开始，让其为0，那么后面可以随便取，然后再到第二位1(0的部分可以跳过，因为在前面已经被取到了)，这时候前面的第一位取1，然后后面随意取…一直加到最后即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
const int N=3e3+5;
char a[N];
ll c;
ll quickpow(ll a,ll b)
{
    ll res=1;
    while(b)
    {
        if(b&1)
        res=res*a%mod;
        b>>=1;
        a=a*a%mod;
    }
    return res;
}
ll C[N][N];
int main()
{
    for(int i=0;i<=3001;++i)
    C[i][0]=1;
    for(int i=1;i<=3001;++i)
    for(int j=1;j<=i;++j)
    C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
    scanf("%s",a);
    scanf("%lld",&c);
    ll ans=0;
    ll now=0;
    int len=strlen(a);
    for(int i=0;i<len;++i)
    {
        if(a[i]=='1')
        {
            int up=len-i-1;
            for(int j=0;j<=up;++j)
            {
                ans=(ans+C[up][j]*quickpow(c,j+now)%mod)%mod;
            }
            now++;
        }
    }
    printf("%lld\n",(ans+quickpow(c,now))%mod);
    return 0;
}

F. Strange Memory

dsu on tree(有时间写篇博客总结一下)，对于dsu on tree有两种类型的题，一种是直接算子树贡献，还有一种就和这题一样计算不同子树间的贡献。因为是要计算不同子树间的贡献，所以需要用到递归。然后本题可以用vector过，正解是要拆位，对于要计算异或和，我们将其拆为20位，对于每一位，记录0和1的个数，对于0来说，异或上1就会产生贡献。所以我们只要统计每位0和1的个数即可，这样时间复杂度为O(20nlogn)。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n;
int a[N];
vector<int>g[N],temp;
int p[(1<<20)+5][20][2];
ll ans;
//ll now;
int siz[N],son[N];
int id_num[(1<<20)+5];
ll pow2[20];
void dfs(int x,int fa)
{
    siz[x]=1;
    son[x]=0;
    for(int i=0;i<g[x].size();++i)
    {
       int v=g[x][i];
       if(v==fa)
       continue;
       dfs(v,x);
       siz[x]+=siz[v];
       if(!son[x]||siz[v]>siz[son[x]])
       {
           son[x]=v;
       }
    }
}
//void get_data(int x,int op)
//{
//    for(int i=L[x];i<=R[x];++i)
//    {
//        if(reg[i]==skp)
//        {
//            i=R[reg[i]];
//            continue;
//        }
//        if(op!=-1)
//        {
//            int val=a[reg[i]]^op;
//            int len=p[val].size();
//            for(int j=0;j<len;++j)
//            {
//                ans+=p[val][j]^reg[i];
//            }
//            p[a[reg[i]]].push_back(reg[i]);
//        }
//        else
//        {
//            p[a[reg[i]]].pop_back();
//        }
//    }
//}
void cal(int x,int fa,int lca)
{
    temp.push_back(x);
    for(int i=0;i<20;++i)
    {
        ans+=1ll*p[a[x]^a[lca]][i][!((x>>i)&1)]*pow2[i];
    }
    for(int i=0;i<g[x].size();++i)
    {
        int v=g[x][i];
        if(v==fa)
        continue;
        cal(v,x,lca);
    }
}
void del(int x,int fa)
{
    if(id_num[a[x]])
    {
        memset(p[a[x]],0,sizeof(p[a[x]]));
        id_num[a[x]]=0;
    }
    for(int i=0;i<g[x].size();++i)
    {
        int v=g[x][i];
        if(v==fa)
        continue;
        del(v,x);
    }
}
void dsu(int x,int fa,bool keep)
{
    //cout<<x<<endl;
    for(int i=0;i<g[x].size();++i)
    {
        int v=g[x][i];
        if(v==fa||v==son[x])
        continue;
        dsu(v,x,0);
    }
    //cout<<x<<" "<<son[x]<<endl;
    if(son[x])
    {
        dsu(son[x],x,1);
    }
    for(int i=0;i<20;++i)
    p[a[x]][i][(x>>i)&1]++;
    id_num[a[x]]++;
    //cout<<x<<" "<<g[x].size()<<endl;
    for(int i=0;i<g[x].size();++i)
    {
        int v=g[x][i];
        //cout<<v<<" "<<x<<" "<<son[x]<<" "<<fa<<endl;
        if(v==fa||v==son[x])
        continue;
        cal(v,x,x);
        for(int j=0;j<temp.size();++j)
        {
            int it=temp[j];
            //int tmp=1;
            for(int k=0;k<20;++k)
            {
                p[a[it]][k][(it>>k)&1]++;
            }
            id_num[a[it]]++;
        }
        temp.clear();
    }
    if(!keep)
    {
        del(x,fa);
        //now=0;
    }
}
int main()
{
    pow2[0]=1;
    for(int i=1;i<20;++i)
    pow2[i]=pow2[i-1]<<1;
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    scanf("%d",&a[i]);
    for(int i=1;i<n;++i)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dfs(1,0);
    dsu(1,0,1);
    printf("%lld\n",ans);
    return 0;
}

H. Combination Lock

待补

J. Abstract Painting

状压dp，只在x轴上，可以将其两边看成是左右扩号。因为圆的半径最多只有5，所以其左括号最多会对其后十个点产生影响，所以可以用状压dp求解。(这里我们将整个图右移一格)我们设dp[i][j]为以第i个点为右括号对于前10个点状态为j的方案数（其中1的位置表示其不能为左括号，0表示可以）。初始情况，dp[0][j]=0，因为图右移了一格，所以此数0的位置为负x轴，不能存在左括号，所以方案数为0。对于当前点的每种状态的dp值，若能由上一个点的dp转移到，其必须满足，当前状态和之前状态要相应，即之前状态不能为左括号的位置，当前状态就不能在那个位置取左括号，(因此之前状态和当前状态相与是0才满足条件)，还有因为之前图上是有圆的，所以还要保证当前状态得满足图上的圆，所以图上圆的状态和当前状态相与得是1，因为如果图上圆的左括号取到与当前圆的左括号相同位置时，就有两个交点了，所以要取到当前状态不能取左括号的地方。因为我们只是枚举了，当前位置为右括号的状态，所以其实际状态实际是其最大扩号的状态或上之前位置的状态再向左移位一次(因为对于后面的点来说，当前点相切也可以，所以可以取左括号)。

#include <bits/stdc++.h>
using namespace std;
int n,k;
int pos[32];
int info[32];
int maxstate=(1<<10)-1;
int dp[1010][(1<<10)];//dp[i][j]代表到第i个位置,[i-9,i]是否被圆包含的二进制状态为(j)2的方案数
//二进制信息(j)2的第k位为1,代表点i-k被包含(不能作圆的左括号),反而反之。
vector<int>v[1010];
const int mod=1e9+7;
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=k;++i)
    {
        int x,r;
        scanf("%d%d",&x,&r);
        v[x+1+r].push_back(2*r);
    }
    memset(info,-1,sizeof(info));
    for(int i=1;i<32;++i)
    {
        int tmp=0;
        for(int j=4;j>=0;j--)
        {
            if((i>>j)&1)
            {
                tmp|=(1<<(j*2+1));
                if(info[i]==-1)
                {
                    info[i]=(1<<(j*2+1))-1;
                }
            }
        }
        pos[i]=tmp;
    }
    pos[0]=info[0]=0;
    dp[0][maxstate]=1;
    for(int i=1;i<=n+1;++i)
    {
        for(int j=0;j<=maxstate;++j)
        {
            for(int k=0;k<32;++k)
            {
                int flag=0;
                for(int p=0;p<v[i].size();++p)
                {
                    int r=v[i][p];
                    if(!(pos[k]&(1<<r-1)))
                    {
                        flag=1;
                    }
                }
                if(flag||(j&pos[k]))
                {
                    continue;
                }
                int now=((j|info[k])<<1)&maxstate;
                dp[i][now]+=dp[i-1][j];
                dp[i][now]%=mod;
            }
        }
    }
    int ans=0;
    for(int i=0;i<=maxstate;++i)
    {
        ans+=dp[n+1][i];
        ans%=mod;
    }
    printf("%d\n",ans);
    return 0;
}

K. Ragdoll

首先，我们看这个式子 gcd(x,y)=x⊕y。我们要获得每一个满足式子的点对，暴力做法是O(n2)的，肯定不行。我们对式子进行调整，两边同时异或x，该式子变为 x⊕gcd(x,y)=y。因为是gcd(x,y)，所以其一定是x的某个因子，所以我们确定一个值为gcd(x,y)，然后对于其每个倍数为x，我们可以找到一个y，再将这些带到这个式子判断一下满不满足条件即可，这样就可以O(nlognlongn)的找到所有点对了。然后对于合并，按秩合并即可(总复杂度nlogn)。剩下操作暴力完成即可(加点O(1)，修改值也是O(1)的因为对于一个值，也就几十个与其符的点对)。

#include <bits/stdc++.h>
using namespace std;
const int N=2e5+5;
const int M=3e5+5;
typedef long long ll;
int gcd(int x,int y)
{
    return y==0?x:gcd(y,x%y);
}
vector<int>g[N];
map<int,int>mp[M];
vector<int>s[M];
int fa[M];
int siz[M];
int n,m;
int a[M];
ll ans;
int find(int x)
{
    if(x==fa[x])
    return x;
    else
    return fa[x]=find(fa[x]);
}
void add_point(int x,int v)
{
    fa[x]=x;
    a[x]=v;
    s[x].push_back(x);
    siz[x]=1;
    mp[x][v]=1;
}
void merge(int x,int y)
{
    int fa_x=find(x);
    int fa_y=find(y);
    if(fa_x==fa_y)
    return ;
    if(siz[fa_x]>siz[fa_y])
    swap(fa_x,fa_y);
    for(int i=0;i<s[fa_x].size();++i)
    {
        int x=a[s[fa_x][i]];
        for(int j=0;j<g[x].size();++j)
        {
            int y=g[x][j];
            ans+=mp[fa_y][y];
        }
    }
    for(int i=0;i<s[fa_x].size();++i)
    {
        int x=s[fa_x][i];
        s[fa_y].push_back(x);
        mp[fa_y][a[x]]++;
    }
    siz[fa_y]+=siz[fa_x];
    fa[fa_x]=fa_y;
}
void update(int x,int v)
{
    int fa_x=find(x);
    for(int i=0;i<g[a[x]].size();++i)
    {
        int y=g[a[x]][i];
        ans-=mp[fa_x][y];
    }
    //cout<<ans<<endl;
    mp[fa_x][a[x]]--;
    a[x]=v;
    for(int i=0;i<g[v].size();++i)
    {
        int y=g[v][i];
        ans+=mp[fa_x][y];
        //cout<<y<<" "<<mp[fa_x][y]<<endl;
    }
    mp[fa_x][v]++;
}
int main()
{
    for(int i=1;i<=200000;++i)
    for(int j=i+i;j<=200000;j+=i)
    {
        if(gcd(j,i^j)==i)
        g[j].push_back(i^j);
    }
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        fa[i]=i;
        mp[i][a[i]]=1;
        siz[i]=1;
        s[i].push_back(i);
    }
    int t,x,y,v;
    while(m--)
    {
        scanf("%d",&t);
        if(t==1)
        {
            scanf("%d%d",&x,&v);
            add_point(x,v);
        }
        else if(t==2)
        {
            scanf("%d%d",&x,&y);
            merge(x,y);
        }
        else
        {
            scanf("%d%d",&x,&v);
            update(x,v);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

L. Coordinate Paper

构造题。首先，如果我们确定了a1，我们就能确定当前序列的最小情况，即a1,a1+1,a1+2,…,k,0,…0,1,2,…k,0,1…。我们可以O(1)求出其和，这样我们知道其和%(k+1)是多少，并且如果要修改序列，其%(k+1)的值是不变的，所以，我们断言如果这个序列能构造出s，其必须满足，其最小值的和%(k+1)与s%(k+1)是一样的且s>=其最小值的和。这样我们可以O(k)的找到a1。找到之后要如何构造呢，就是先对0的位置加(k+1)，再对1的位置加(k+1)…即可(试一下就知道其正确性，这样做是肯定合法的)。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
ll n,k,s;
ll ans[N];
struct node
{
    ll val;
    int id;
}tmp[N];
bool cmp(node a,node b)
{
    return a.val<b.val;
}
ll get_ar(ll a)
{
    return ((a+1)*a)>>1;
}
ll get_sum(ll a,ll b)
{
    ll sum=0;
    ll up=k-a+1;
    if(b<up)
    {
        return get_ar(a+b-1)-get_ar(a-1);
    }
    else
    {
        sum+=get_ar(k)-get_ar(a-1);
    }
    ll num=(b-up)/(k+1);
    ll num2=(b-up)%(k+1);
    sum+=get_ar(k)*num;
    sum+=get_ar(num2-1);
    return sum;
}
void construct_ans(ll pos)
{
    ll num=(s-get_sum(pos,n))/(n*(k+1));
    ll num2=(s-get_sum(pos,n))%(n*(k+1));
    num2=num2/(k+1);
    ans[1]=pos;
    tmp[1].id=1;
    tmp[1].val=pos;
    for(int i=2;i<=n;++i)
    {
        ans[i]=(ans[i-1]+1)%(k+1);
        tmp[i].id=i;
        tmp[i].val=ans[i];
    }
    sort(tmp+1,tmp+1+n,cmp);
    for(ll i=1;i<=num2;++i)
    {
        ans[tmp[i].id]+=(k+1);
    }
    for(int i=1;i<=n;++i)
    {
        ans[i]+=num*(k+1);
    }
}
int main()
{
    scanf("%lld%lld%lld",&n,&k,&s);
    int pos;
    bool flag=0;
    for(int i=0;i<=k;++i)
    {
        ll a1=i;
        if((s%(k+1)==get_sum(a1,n)%(k+1))&&s>=(get_sum(a1,n)))//可以找到解
        {
            flag=1;
            pos=i;
            break;
        }
    }
    if(!flag)
    puts("-1");
    else//构造答案
    {
        construct_ans(pos);
        for(int i=1;i<=n;++i)
        printf("%lld ",ans[i]);
        puts("");
    }
    return 0;
}
hhhcbw
关注
2018ccpc吉林站Wannflyak代码
09-24
【标签】"ccpc吉林站a"进一步明确了这是关于CCPC吉林站A类问题的代码，可能是指比赛的第一道题目，或者根据竞赛的分类系统，"A"代表某个特定难度或类型的题目。 从【压缩包子文件的文件名称列表】"ccpc"来看，这个...
【2020ccpc长春站】L题 Coordinate Paper（构造）详解
Qiuker_jl的博客
11-13 1274
题目链接：https://codeforces.com/gym/102832/problem/L 题目大意： 构造一个满足下面条件的长度为n的序列： ①序列中的任意一个数都是非负整数 ②序列中所有数之和为s ③相邻的两个数满足或 其中n，s，k都由题目给出（1≤n,k≤，1≤s≤） 分析： 第一步: 我先画了这样一个图(先不考虑ai-k会小于0) 有点丑QAQ a是这个序列的第一个元素 可以很轻易的发现,在所有方案下(即不管后面的元素是+1还是-k),序列所有元素的和都...
2020 CCPC 长春 K. Ragdoll(预处理+启发式合并)
jziwjxjd的博客
05-25 471
LINK 考虑x⊕y=gcd(x,y)x\oplus y=gcd(x,y)x⊕y=gcd(x,y)的情况应该是非常少的 不妨设x>yx>yx>y 由于x⊕y>=x−y>=gcd(x,y)x\oplus y>=x-y>=gcd(x,y)x⊕y>=x−y>=gcd(x,y) 显然等号应该同时取到,得到x⊕y=x−y=gcd(x,y)x\oplus y=x-y=gcd(x,y)x⊕y=x−y=gcd(x,y) 枚举约数kkk作为gcd(x,y)gcd(x,y)
ccpc长春-K. Ragdoll（启发式合并、并查集、gcd转化）map的神奇tle
手扶拖拉机如何改装四驱
11-25 495
K. Ragdoll 菜死我得了 unordered_map<int, LL> mp[maxn];//存连通块内元素a[i] vector<int> g[maxn];//存数字大小为下标的解 int f[maxn], sz[maxn];//并查集 int a[maxn]; LL ans; int find(int x) { if (f[x] == x)return x; else return f[x] = find(f[x]); } void merge(int x, int
2020CCPC长春站
weixin_44203780的博客
11-09 907
2020CCPC长春站 比赛过程 一来我们分开看题，从前到后，从后到前，然后我看中间的D题。 一看感觉可以做，先上去打了个表，然后发现规律了，这时候队友说A题是签到题可以写，然后我就让出了电脑，然后我把D题跟队友说一下后修正思路确认了，然后等A题过了我就上去写D题，最后F题队友说启发式暴力合并可以过，但是需要维护一个集合的异或和，最后想到只要按位拆分01的个数维护起来就可以了，然后两个半小时得时候就过了，最后还刻了JKL三道题，最后三个人决定一起写K，然后一开始思路绕进去了，最后队友说一开始的思路是错的，这
2020CCPC长春站部分题解（pre）
Irving0323的博客
11-09 3515
2020CCPC长春站
2020CCPC河南省赛正式赛答案（官方版）.pdf
08-24
2020年河南省CCPC大赛是ACM竞赛的一个区域赛事，其答案提供了参赛队伍解题思路和算法解析。 1. **班委竞选**：这是一个关于最大票数的问题。题目中提到，需要从小到大枚举学号，如果当前学号的票数超过当前类别的...
2020CCPC河南省赛正式赛.pdf
08-24
2020年河南省CCPC大赛属于ACM竞赛的区域赛事，这类比赛通常包含多道编程题目，参赛队伍需要在限定时间内编写程序解决这些问题。 【Problem A - 班委竞选】是一道基于数据处理和排序的问题。题目要求根据学生的学号...
CCPC2020长春-K-并查集启发式合并map
qq_35577488的博客
11-09 368
题目大意: 直接题意:给你n个点,带点权aia_iai​。操作m次,模拟并查集的合并过程，每次操作之后询问每个集合中满足gcd(ai,aj)=ai⊕ajgcd(a_i,a_j)=a_i \oplus a_jgcd(ai​,aj​)=ai​⊕aj​的点对个数.还有对点权的修改. n,m≤1e5n,m \leq 1e5n,m≤1e5 题目思路： 其实这题很显然。让我们维护并查集内部的信息,无非就是线段树合并或者启发式合并set/map嘛.复杂度都是O(nlognlogn)O(nlognlogn)O(nlognl
CCPC2020长春 J. Abstract Painting（状压dp）
MorphLing_的博客
11-08 2503
J. Abstract Painting（状压dp） 题意 给定n，在x轴[0,n]范围内画半径不超过5的圆，圆心在x轴上，要求任意两个圆不相交（可以相切），且已有固定的k个圆，求满足条件的画法方案数。 分析 很明显从dp的角度思考，一开始考虑区间dp，但是总状态数O(n2)O(n^2)O(n2) ，转移O(n)O(n)O(n)，总复杂度O(n3)O(n^3)O(n3)，超时。 于是从线性dp的角度考虑，发现因为圆的半径小于等于5，因此某一点的情况只对从这一点往后10个点有后效性，也就是说可以用状态压缩的
2020CCPC长春F题——dsu on tree+二进制拆分
mumei的博客
11-13 401
题目链接 https://codeforces.com/gym/102832/problem/F 题意： 给你一颗n个节点的树，让你求出 的值。 题解： 对于这种子树查询的问题，常用的方法也就那几种，要么就是树链剖分后用数据结构维护，要么就是dsu on tree。 不难发现这个题用dsu on tree比较好写，即考虑以每个节点为根(即lca)的子树，然后枚举不同儿子之间对答案的贡献。 dsu on tree常见的套路是处理子树内的查询，而对于这种子树间的查询就需要对dsu on.
2020(11.01)-CCPC-绵阳-（D,G,J,K,L）题解
qq_43461168的博客
11-07 2989
D.Defuse the Bombs（二分答案） 思路：直接二分答案K，判断能不能在K次操作以内，把所有的数都变成 >= K就行了。最后答案等于K+1 AC代码： #include <bits/stdc++.h> #define int long long #define showcase cout<<"Case #"<<cas++<<": "; using namespace std; int a[100050]; int T,cas = 1; int
2020.11.8 2020CCPC长春区域赛总结
一只酷酷光儿的博客
11-10 3776
回顾一下上个周末吧 从开学准备到上周的的一场比赛尽全力准备了虽然结果并不太理想(铜牌第二名)对我及我们队伍而言这是第一场ccpc也是最后一场ccpc今年四个赛区选到了强校较多的赛区也算是自己的"运气"比赛开始前看到参赛手册心凉一半亨亨用笔标记预估比我们强的队伍标记到第二页就80+了其实我们心里都清楚我说"兵来将挡水来土掩"因为在前三场中有两场是银牌的就算强队再多实力也是有的 ​比赛前一晚上睡的很早11点就睡了睡前对自己说多点数据结构题毕竟是个数据结构选手早上起床和...
2020年ccpc长春站D-Meaningless Sequence
林苏泽
11-09 652
首先引用一下大佬的博客 推一下为什么是这样的： 首先：当二进制是满1的话就是∑i=0xai=(1+c)n\sum_{i=0}^{x}a_{i} = (1+c)^{n}∑i=0x​ai​=(1+c)n其中nnn为xxx的二进制位数，这个其实很容易就能看出来吧按我的思路说一下：相当于一共nnn位在nnn位取小于等于nnn个1其实就是组合数Cn0∗c0+Cn1∗c1+...+Cnn∗cn=(1+c)nC_{n}^{0}*c^{0}+C_{n}^{1}*c^{1}+...+C_{n}^{n}*c^{n} = (1.
CCPC长春站 2020部分题解
Zenith_Habitant的博客
11-10 674
Strange Memory 本题采用DSU On Tree + 拆位，这个题目采用启发式合并很容易想到，关键是如何加速计算贡献的过程，首先，遍历每一个点然后寻找前缀树中对应的点是必不可少的，但是这里，我们可以开一个数组A[X][Y][Z],前缀树中，设一个点的编号为ID，则数组表示在前缀树中所有权值为X的编号中第Y位为Z的数量，这样的话，我们只需要对遍历到的点进行二进制拆位，检查前缀树中0/1的数量便可以加速计算贡献的过程了 //#define LOCAL #include <bits/stdc.
2020ccpc长春(Strange Memory)
黑大帅的博客
11-09 798
Strange Memory Once there was a rooted tree. The tree containednnodes, which were numbered1,…,n. The node numbered1was the root of the tree. Besides, every nodeiwas assigned a numbera​i​​. Your were surprised to find that there were several pai...
关于2020acm-ccpc长春站参赛有感
aconacon的博客
11-10 614
2020acm-ccpc长春站 2020年11月8号身为大二的我第一次参加ccpc长春站，满怀希望的我兴致勃勃的开始这场比赛。一开始的A题我们一看就共同认为是贪心策略，后来wa了发现并不是这样，应该采用暴力的模式枚举，尽管我们用了多重背包的方法将此题a了出来，但是由于时间问题我们 处于落后，后来跟着榜看了d题，队友们推了好久，代码样例过了，却wa了，在我们反复思考中，电脑突然蓝屏了，我们连忙重启和重新请求登录 ，这让我们队员的心态出了问题，浪费了半个小时后，我们连上了，也是飞快的敲了起来，在不断对拍校队后，
2020 ccpc 长春站 F - Strange Memory
shejunda的博客
11-13 214
题意： 给一颗树，每个点有权值a[i]，（u，v）合法仅当a[u]^a[v]=a[lca(u,v]，这样的点对对答案的贡献为u^v，求最后的答案（（u，v）和（v，u）视作相同点对 题解： 参考：https://blog.csdn.net/qq_45458915/article/details/109583484 dsu on tree #include<bits/stdc++.h> using namespace std; #define ll long long const i
j. abstract painting
最新发布
04-10
抽象画是一种艺术风格，其作品通常不具体地展现具体物体或情景，而是强调形式、颜色、线条和材料等方面，以抽象的、非具象的形式表现情感和思想。这种艺术形式不仅在西方艺术中盛行，也受到了许多亚洲艺术家的喜爱和创作。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值