2021.12.23--补题篇--小白白月赛30

 A--黑白边

发现了并查集可以用来判断图的连通性，本题的做法就是先连接黑边，然后在图连通的情况下，dfs，看哪些点还未在图中，吗，每次dfs相当于白边的数量加一。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <stack>
using namespace std;
 
#define pair(a, b) make_pair(a, b)
#define max(a, b) (a) > (b) ? (a) : (b)
#define min(a, b) (a) < (b) ? (a) : (b)
 
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
 
const int N = 2e5 + 10;
const int M = 4e5 + 10;
const int Mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int P = 13331;
 
int n, m, k;
int h[N], e[M], ne[M], idx;
int p[N], siz[N];
bool st[N];
 
void add(int a, int b)
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

int find(int x)
{
    return x == p[x] ? x : p[x] = find(p[x]);
}
void dfs(int fa)
{
    st[fa]=true;
    for(int i=h[fa];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(st[j]) continue;
        dfs(j);
        
    }
}

int main()
{
    int a,b,c;
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i=1;i<=n;i++)
    {
        siz[i]=1;
        p[i]=i;
    }
    for(int i=1;i<=m;i++)
    {
        cin>>a>>b>>c;
        if(!c) add(a,b),add(b,a);
        
        int pa=find(a), pb=find(b);
        if(pa==pb) continue;
        if(pa!=pb)
        {
            p[pa]=pb;
            siz[pb]+=siz[pa];
        }
    }
    
    if(siz[find(n)]==n)
    {
        
        int res=-1;
        for(int i=1;i<=n;i++)
        {
            if(!st[i])
            {
                dfs(i);
                res++;
            }
        }
        cout<<res;
    }
    
    
    else cout<<-1<<endl;
    
        
        
    
    
    
    
    
    
    
    
    return 0;
}
 

J---小游戏

简单dp，状态转移方程的含义为：dp【N】【2】，第一维度表示遍历到第几个数，二维表示这个数选还是不选，很容易发现状态转移方程就是当选这个数时，只能从前一个数不选迁移，并加上这个数带来的贡献，

不选这个数时，可以从前一个数max（选，不选）迁移。

答案找最大值即可。

#include<iostream>
using namespace std;

int n,m;
const int N=2e5+10;
long long a[N];
long long  dp[N][2];
int cnt[N];
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) 
    {
        cin>>a[i];
        cnt[a[i]]++;
    }
    for(int i=1;i<=N;i++)
    {
        dp[i][0]=max(dp[i-1][0],dp[i-1][1]);
        dp[i][1]=dp[i-1][0]+cnt[i]*i;
    }
  cout<<max(dp[N][0],dp[N][1]);
}

区间异或

一开始确实有点难想，如何在短时间复杂度下查找大于等于其的第一个值呢？转换思路后，其实可以这样---记录定长度的最大异或值，因为n只有3000，这样每次遍历复杂度不会超过1e10。

#include<iostream>
using namespace std;
 
int n,m;
const int N=1e5+10;
long long  a[3001][3001];
int xo[3001];
long long fin[N];
int op;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) {cin>>a[i][i];
    fin[1]=max(fin[1],a[i][i]);}
    
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
        {
            a[i][j]=a[i][j-1]^a[j][j];
            fin[j-i+1]=max(fin[j-i+1],a[i][j]);
        }

    for(int i=1;i<=m;i++)
    {
        cin>>op;
           int ans = -1;
        for (int i = 1; i <= n; i ++)
            if (fin[i] >= op)
            {
                ans = i;
                break;
            }
             cout<<ans<<endl;
    }
}

D-GCD

很容易发现规律---- 由于是任意选，那么出现多个质数的子集合肯定不行，那么问题就转换为，给定数范围内质数的个数（质数筛一下就行），将这个个数加一就是k的最小值。

#include<iostream>
using namespace std;
const int N=1e6;
int prime[N];
int cnt;
bool st[N];
int n;
int main()
{
    cin>>n;
     for(int i=2;i<=n;i++)
    {
        if(!st[i]) prime[cnt++]=i;
        for(int j=0;prime[j]<=n/i;j++)
        {
            st[prime[j]*i]=true;
            
            if(i%prime[j]==0) break;
        }
    }
    cnt++;
    
    if(cnt==n) cout<<-1;
    else cout<<(cnt+1);
}

其他都是水题，没什么好记录的了。