2019 Multi-University Training Contest 6

Salty Fish

Support or Not

Three Investigators

Milk Candy

Ridiculous Netizens

#include <bits/stdc++.h>

using namespace std;
const int maxn=5100;
const int mod=1e9+7;
int head[maxn],t,son[maxn],m,f[maxn],n,now,a[maxn],cnt,tmp[maxn],kuai[3000],dp[maxn][3000],ok[maxn],ans;

struct edge
{
    int v,next;
} e[5100];

void add(int u,int v)
{
    t++;
    e[t].v=v;
    e[t].next=head[u];
    head[u]=t;
    ok[t]=1;
}

void get_root(int u,int fa)
{
    son[u]=1;
    f[u]=0;
    for (int i=head[u]; i; i=e[i].next)
        if (ok[i]&&e[i].v!=fa)
        {
            int v=e[i].v;
            get_root(v,u);
            son[u]+=son[v];
            f[u]=max(f[u],son[v]);
        }
    if (n-son[u]>f[u])
        f[u]=n-son[u];
    if (f[u]<f[now])
    {
        now=u;
    }
}

void dfs(int x,int y)
{
    int k=a[x];
    for (int i=1; i<=cnt; i++)
    {
        tmp[i]=0;
    }
    for (int i=1,j=1; i<=cnt; i++)
    {
        int t=kuai[i]/k;
        if (t==0)
        {
            continue;
        }
        while (kuai[j]>t)
        {
            j++;
        }
        tmp[j]=(tmp[j]+dp[x][i])%mod;
    }
    for (int i=1; i<=cnt; i++)
    {
        dp[x][i]=tmp[i];
    }
    for (int i=head[x]; i; i=e[i].next)
    {
        if (ok[i])
        {
            int u=e[i].v;
            if (u==y)
            {
                continue;
            }
            for (int j=1; j<=cnt; j++)
            {
                dp[u][j]=dp[x][j];
            }
            dfs(u,x);
            for (int j=1; j<=cnt; j++)
            {
                dp[x][j]=(dp[x][j]+dp[u][j])%mod;
            }
        }
    }
}

void solve(int u)
{
    for (int i=1; i<=cnt; i++)
    {
        dp[u][i]=0;
    }
    dp[u][1]=1;
    dfs(u,0);
    for (int i=1; i<=cnt; i++)
    {
        ans=(ans+dp[u][i])%mod;
    }
    for (int i=head[u]; i; i=e[i].next)
    {
        if (ok[i])
        {
            ok[i^1]=0;
            f[0]=n=son[e[i].v];
            get_root(e[i].v,now=0);
            solve((now));
        }
    }
}

int main()
{
   // freopen("1.txt","r",stdin);
    int _;
    scanf("%d",&_);
    while (_--)
    {
        t=1;
        scanf("%d%d",&n,&m);
        cnt=ans=0;
        for (int i=1; i<=n; i++)
        {
            son[i]=f[i]=head[i]=0;
            scanf("%d",&a[i]);
        }
        for (int i=1; i<=m; i=m/(m/i)+1)
        {
            kuai[++cnt]=m/i;
        }
        for (int i=1,u,v; i<n; i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        f[0]=n;
        get_root(1,now=0);
        solve(now);
        printf("%d
",ans);
    }
    return 0;
}

Stay Real

#include <bits/stdc++.h>
 
using namespace std;
 
const int maxn=100010;
typedef long long ll;
struct node
{
    ll val,id;
    node(int _val,int _id):val(_val),id(_id) {};
    bool operator < (const node &b)const
    {
        return val<b.val;
    }
};
 
ll h[maxn],vis[maxn*2],n,suma,sumb,flag,fa;
priority_queue<node>q;
 
int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%lld",&n);
        for (int i=1; i<=n; i++)
        {
            vis[i]=1;
        }
        for (int i=1; i<=n; i++)
        {
            scanf("%lld",&h[i]);
            if (vis[i<<1]==0&&vis[i<<1|1]==0)
            {
                q.push(node(h[i],i));
            }
        }
        suma=sumb=0;
        flag=1;
        while (!q.empty())
        {
            node tmp=q.top();
            q.pop();
            if (flag)
            {
                suma+=tmp.val;
            }
            else
            {
                sumb+=tmp.val;
            }
            vis[tmp.id]=0;
            flag^=1;
            fa=tmp.id>>1;
            if (vis[fa<<1]==0&&vis[fa<<1|1]==0&&fa!=0)
            {
                q.push(node(h[fa],fa));
            }
        }
        printf("%lld %lld
",suma,sumb);
    }
    return 0;
}

TDL

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
ll k,m,i,flag,cnt,kk;
int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        flag=0;
        scanf("%lld%lld",&k,&m);
        for (i=max(1ll,k-1000); i<=k+1000; i++)
        {
            cnt=0;
            for (ll j=i+1;; j++)
            {
                if (__gcd(i,j)==1)
                {
                    cnt++;
                    if (cnt==m)
                    {
                        kk=j;
                        break;
                    }
                }
            }
            if (cnt==m&&((kk-i)^i)==k)
            {
                flag=1;
                break;
            }
        }
        if (flag)
        {
            printf("%lld
",i);
        }
        else
        {
            puts("-1");
        }
    }
    return 0;
}

Snowy Smile

#include<bits/stdc++.h>
 
using namespace std;
const int maxn=2001;
typedef long long ll;
struct node
{
    int l,r;
    ll d,lmax,rmax,sum;
} tree[maxn+maxn-100];
 
int x[maxn],y[maxn],w[maxn],xx[maxn],yy[maxn],n,dp[maxn][maxn];
ll ans;
 
vector<pair<int,int> >a[maxn];
 
inline int read()
{
    int res=0,f=1;
    char ch=getchar();
    while (!isdigit(ch))
    {
        if (ch=='-')
        {
            f=-f;
        }
        ch=getchar();
    }
    while (isdigit(ch))
    {
        res=(res<<3)+(res<<1)+ch-'0';
        ch=getchar();
    }
    return f*res;
}
 
 
inline void build (int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    if (l==r)
    {
        tree[rt].lmax=tree[rt].rmax=tree[rt].sum=tree[rt].d=0;
        return;
    }
    int mid=(l+r)>>1;
    build (rt<<1,l,mid);
    build (rt<<1|1,mid+1,r);
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
 
    tree[rt].lmax=max(tree[rt<<1].lmax,tree[rt<<1].sum+tree[rt<<1|1].lmax);
 
    tree[rt].rmax=max(tree[rt<<1|1].rmax,tree[rt<<1|1].sum+tree[rt<<1].rmax);
 
    tree[rt].d=max(tree[rt<<1].d,max(tree[rt<<1|1].d,tree[rt<<1|1].lmax+tree[rt<<1].rmax));
}
 
inline void change(int rt,int pos,ll d)
{
    if (tree[rt].l==tree[rt].r)
    {
        tree[rt].lmax=tree[rt].rmax=tree[rt].sum=tree[rt].d+=d;
        return;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    if (pos<=mid)
    {
        change(rt<<1,pos,d);
    }
    else
    {
        change(rt<<1|1,pos,d);
    }
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
 
    tree[rt].lmax=max(tree[rt<<1].lmax,tree[rt<<1].sum+tree[rt<<1|1].lmax);
 
    tree[rt].rmax=max(tree[rt<<1|1].rmax,tree[rt<<1|1].sum+tree[rt<<1].rmax);
    tree[rt].d=max(tree[rt<<1].d,max(tree[rt<<1|1].d,tree[rt<<1|1].lmax+tree[rt<<1].rmax));
}
 
int main()
{
    int T,posx,posy,nx,ny,len;
    T=read();
    while (T--)
    {
        n=read();
        for (register int i=1; i<=n; i++)
        {
            x[i]=read();
            y[i]=read();
            w[i]=read();
            xx[i]=x[i];
            yy[i]=y[i];
            a[i].clear();
            for (register int j=1; j<=n; j++)
            {
                dp[i][j]=0;
            }
        }
        sort(xx+1,xx+n+1);
        sort(yy+1,yy+n+1);
        nx=unique(xx+1,xx+n+1)-(xx+1);
        ny=unique(yy+1,yy+n+1)-(yy+1);
        for (register int i=1; i<=n; i++)
        {
            posx=lower_bound(xx+1,xx+nx+1,x[i])-xx;
            posy=lower_bound(yy+1,yy+ny+1,y[i])-yy;
            if(dp[posy][posx]==0)
            {
                a[posy].push_back(make_pair(posx,posy));
            }
            dp[posy][posx]+=w[i];
        }
        build (1,1,nx);
        ans=0;
        for (register int i=1; i<=ny; i++)
        {
            for (register int j=i; j<=ny; j++)
            {
                len=a[j].size();
                for (register int k=0; k<len; k++)
                {
                    change(1,a[j][k].first,dp[a[j][k].second][a[j][k].first]);
                }
                ans=max(ans,tree[1].d);
            }
            build (1,1,nx);
        }
        printf("%lld
",ans);
    }
}

Faraway

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
int n,m,xe[100],ye[100],x[100],y[100],a[100],b[100];
ll ans;
bool check(int x,int y)
{
    for (int i=1; i<=n; i++)
    {
        if ((abs(x-xe[i])+abs(y-ye[i]))%a[i]!=b[i])
        {
            return 0;
        }
    }
    return 1;
}

int cal(int l,int r)
{
    r-=l;
    if (r<0)
    {
        return 0;
    }
    return r/60+1;
}

int main()
{
    int _;
    scanf("%d",&_);
    while (_--)
    {
        scanf("%d%d",&n,&m);
        ans=0;
        for (int i=1; i<=n; i++)
        {
            scanf("%d%d%d%d",&xe[i],&ye[i],&a[i],&b[i]);
            x[i]=xe[i];
            y[i]=ye[i];
        }
        x[0]=0;
        y[0]=0;
        x[n+1]=m+1;
        y[n+1]=m+1;
        sort(x,x+n+2);
        sort(y,y+n+2);
        for (int i=0; i<=n; i++)
        {
            for (int j=0; j<=n; j++)
            {
                for (int k=0; k<60; k++)
                {
                    for (int l=0; l<60; l++)
                    {
                        int xx=x[i]+k;
                        int yy=y[j]+l;
                        if (check(xx,yy))
                        {
                            ans+=1ll*cal(xx,x[i+1]-1)*cal(yy,y[j+1]-1);
                        }
                    }

                }
            }
        }
        printf("%lld
",ans);
    }
    return 0;
}

Nonsense Time

#include <bits/stdc++.h>
const int maxn = 5e4+5;
using namespace std;
int a[maxn], b[maxn], c[maxn], d[maxn];
int vis[maxn], used[maxn], path[maxn], n;
int solve()
{
    int len=0;
    for (int i=1; i<=n; i++)
    {
        if (vis[a[i]]==-1) continue;
        int it=lower_bound(d,d+len,a[i])-d;
        if (it==len)
        {
            d[len++]=a[i];
            path[i]=len;
        }
        else
        {
            d[it]=a[i];
            path[i]=it+1;
        }
    }
    memset(used,0,sizeof(used));
    int tmp=len;
    for (int i=n; i>=1; i--)
    {
        if (vis[a[i]]==-1)
        {
            continue;
        }
        if (path[i]==tmp)
        {
            used[a[i]]=1;
            tmp--;
        }
    }
    return len;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        memset(vis,0,sizeof(vis));
        scanf("%d",&n);
        for (int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        for (int i=1; i<=n; i++)
        {
            scanf("%d",&b[i]);
        }
        c[n]=solve();
        for (int i=n-1; i>=1; i--)
        {
            vis[a[b[i+1]]]=-1;
            if (used[a[b[i+1]]]==0)
            {
                c[i]=c[i+1];
            }
            else
            {
                c[i]=solve();
            }
        }
        for (int i=1; i<=n; i++)
        {
            printf("%d",c[i]);
            if (i==n)
            {
                printf("
");
            }
            else
            {
                printf(" ");
            }
        }
    }
}

Speed Dog

11 Dimensions