日常训练(1)

6月9日：牛客算法周练10  https://ac.nowcoder.com/acm/contest/5986#question

B题：暴力出奇迹

思路：采用二进制贪心,如果当前位置贡献为连续1的则记录答案。和线性基的想法类似,选择对于当前位存在贡献的一位。

关于线性基：https://oi-wiki.org/math/basis/

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1e5+10;
typedef long long ll;
int main()
{
    int a[maxn],n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    ll ans=0;
    for(int i=0;i<20;i++)
    {
        ll tmp=a[1],sum=0;
        for(int j=1;j<=n;j++)
        {
            if(a[j]>>i&1)
            {
                tmp&=a[j];
                sum+=a[j];
                ans=max(ans,tmp*sum);
            }
            else
            {
                tmp=a[j+1];
                sum=0;
            }
        }
    }
    printf("%lld",ans);
    return 0;
}

 

F题：树上求和

 思路：每条边被计算的数目等于这条边两边的节点的个数之积。然后按照积这个权值进行排序，依次赋值1，2 ......n-1

所以我们只要统计每个边的左侧和右侧有多少顶点就可以。

这里的DFS很不一样...

代码如下：

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;

vector<ll> q[maxn];
vector<ll> p;
ll n; 

ll dfs(ll u,ll v)
{
    ll sum=1;
    for(int i=0;i<q[u].size();i++)
    {
        if(q[u][i]!=v)
        {
            sum+=dfs(q[u][i],u);
        }
    }
    p.push_back(sum*(n-sum));
    return sum;
}
int main()
{
    ll a,b;
    cin>>n;
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&a,&b);
        q[a].push_back(b);
        q[b].push_back(a);
    }
    dfs(1,-1);
    sort(p.begin(),p.end());
    ll s=0,l=n-1;
    for(int i=1;i<p.size();i++)
    {
        s+=p[i]*l;
        l--;
    }
    printf("%lld",s);
    return 0;
}

 

6月12日：

A题：UVALive - 3644   X-Plosives  链接：https://vjudge.net/problem/UVALive-3644

题意：给定一些组合，以”-1“结束，如果出现类似”A+B""B+C""A+C"这样的环路组合，那么此时就是危险的。按输入顺序，判断加入一个组合后是否是危险状态，如果是，那么就拒绝这个组合加入（装车）。统计拒绝的个数。

思路：判断是否存在环路的问题，可以使用并查集。

注意这里的多组输入的处理问题。

代码如下：

 

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=1e5+10;
int f[maxn];
int find(int x)
{
    if(f[x]==x)
    return x;
    return find(f[x]);
}
int main()
{
    int n;
    int x,y,ans=0;
    while(~scanf("%d",&x))//多组输入 
    {
        ans=0;
        for(int i=1;i<=maxn;i++)
        {
        f[i]=i;
        }
        while(x!=-1)
        {
        scanf("%d",&y);
        x=find(x);
        y=find(y);
        if(x==y) 
        ans++;
        else
        f[y]=x;
        scanf("%d",&x);
        }
    printf("%d\n",ans);
}
    return 0;
}

 

 

B题： UVALive - 3027  Corporative Network  链接：https://vjudge.net/problem/UVALive-3027

题意：n个节点，若干次询问，I x y表示从x连一条边到y，权值为｜x-y｜%1000；E x表示询问x到x所指向的终点的距离。

题意也太难理解了。。。

思路：带权并查集。在本题，节点到根节点的值需要随时更新，用一个数组记录到根节点的距离。在查询时更新节点的值。

代码如下：

#include<iostream>
#include <cstdio>
#include <cmath>
const int maxn=20100;

int f[maxn],dis[maxn];
int n;

int find(int x)
{
    if(f[x]==x)
        return x;
    int tmp=f[x];
    f[x]=find(f[x]);
    dis[x]=dis[x]+dis[tmp];//求x到根节点的距离。注意顺序，否则dis[x]就不能代表x到新根的距离了
    return f[x];
}
void Uion(int a,int b)
{
    int ra=find(a);
    int rb=find(b);
    if(ra!=rb)
    {
        f[ra]=rb;
        dis[ra]=(abs(a-b)%1000-dis[a]+dis[b]);//向量运算，得出ra到rb的距离
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            f[i]=i;
            dis[i]=0;
        }
        getchar();
        char ch;
        while(scanf("%c",&ch))
        {
            if(ch=='O')
            break;
            if(ch=='I')
            {
                int a,b;
                scanf("%d %d",&a,&b);
                Uion(a,b);
                getchar();
            }
            else
            {
                int a;
                scanf("%d",&a);
                find(a);//注意这里，查询的时候也要压缩一下，因为uion操作会更新dis数据
                printf("%d\n",dis[a]);
                getchar();
            }
        }
    }
    return 0;
}

 

6月13日：

B题：Lose it!  CodeForces - 1176C   链接：https://vjudge.net/problem/CodeForces-1176C

题意：一次输入两个数，代表这两个数之间可以发生化学反应，此时危险值*2，问最大的危险值是多少。

思路：一个数可能与多个数发生反应，而另外多个数可能和这个数发生反应，两两之间又多对多，想到利用并查集来解决。设定根节点，与根节点在一个集合中的元素可以和根节点发生反应，此时*2，统计即可。

注意最终结果要开long long

代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int f[200];
int find(int x)
{
    if(f[x]==x)
    return x;
    else
    return find(f[x]);
}
int main()
{
    int x,y,n,m;
    long long ans=1;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    f[i]=i;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        x=find(x);
        y=find(y);
        f[y]=x;
    }
    for(int i=1;i<=n;i++)
    {
        if(f[i]!=i)//根节点与自己不可能发生反应 
        ans*=2;
    }
    printf("%lld",ans);
    return 0;
}

 

A题：Lose it!  CodeForces - 1176C   链接：https://vjudge.net/problem/CodeForces-1176C

题意：将[4,8,15,16,23,42]定义为一个好的序列，这个序列的顺序不能变，或者你能从一个序列中的到定序的这个序列且没有多余的元素也成为好序列。你会得到一个序列，问你需要删除多少个元素，才能将其变成好序列。

思路：map是个好东西，用map来表示下标与对应数，vis[]数组表示一个数出现的次数，如果42后边有元素，就把出现的元素集中到vis[6]上，因为其对应42。看能移动到6的个数。

需要理解题意，并分析规律。

代码如下：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<map>
using namespace std;
int n,m,vis[10];
map<int,int>mp;
int main()
{
    while(cin>>n)
    {
        mp[4]=1;
        mp[8]=2;
        mp[15]=3;
        mp[16]=4;
        mp[23]=5;
        mp[42]=6;
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            cin>>m;
            if(mp[m]==1)
                vis[1]++;
            else if(vis[mp[m]-1]>0)
            {
                vis[mp[m]-1]--;
                vis[mp[m]]++;
            }
        }
        cout<<n-vis[6]*6<<endl;
    }
    return 0;
}