「训练日志 20」 6.19 差距

这次考试题解好像都写在题面上了。。

贪婪。

离。

堆积。

T1 嚎叫响彻在贪婪的厂房

　　等差序列，要保证第i位与第i-1位的差值与之前的所有集合中的数中任意两个相邻数的差值gcd不为1，还有序列中没有重复元素。

　　考试的时候想的是分解质因数，然后崩了，又难想又难打。

　　其实思路挺简单，实现的话用一个$map$$/$$set$$/$$hash$判重搞定然后没什么了。

　　为什么没想到$gcd$呢？还是考试把自己搞死了，自己没想到这一点，只想这分解，最后也没有码出来。

　　多方向找性质，不要受局限。

　　小弟不才。

#include<cstdio>
#include<cmath>
#include<map>
#include<limits>
#define LL long long 
#define HZOI std
using namespace HZOI;
const int HASH=19260817;
const int Hash=233;
const int N=1e7+3;
LL n,cnt,lst,ans,gcd;
LL a[N];
unsigned LL hs[HASH+3];
map<LL ,bool > mp;
inline void Add(LL ,int );
inline LL Ask(LL );
LL Gcd(LL ,LL );
inline LL read();
inline LL max(LL a,LL b) {return a>b?a:b;}
inline LL min(LL a,LL b) {return a<b?a:b;}
inline LL _abs(LL a) {return a<0?-a:a;}
int main()
{
    n=read();
    for (int i=1; i<=n; ++i) a[i]=read();
    Add(a[1],1),cnt=lst=1;
    for (int i=2; i<=n; ++i)
    {
        if (cnt==1)
        {
            if (a[i]==a[i-1]) {lst=i;++ans;continue;}
            ++cnt,Add(a[i],1);
            gcd=_abs(a[i]-a[i-1]);
            if (gcd==1)
            {
                Add(a[i-1],-1);
                ++ans; lst=i; cnt=1;
            }
            continue;
        }
        if (Ask(a[i])) 
        {
            ++ans;
            for (int j=lst; j<i; ++j) Add(a[j],-1);
            lst=i, cnt=1, Add(a[i],1);
            continue;
        }
        LL negcd=Gcd(gcd,_abs(a[i]-a[i-1]));
        if (negcd<=1)
        {
            ++ans;
            for (int j=lst; j<i; ++j) Add(a[j],-1);
            lst=i, cnt=1, Add(a[i],1);
            continue;
        }
        gcd=Gcd(gcd,negcd);
        Add(a[i],1),++cnt;
    }
    printf("%lld\n",ans+1);
}
LL Gcd(LL a,LL b)
{
    if (!b) return a;
    return Gcd(b,a%b);
}
inline void Add(LL x,int data)
{
    unsigned LL num=x*Hash*Hash*Hash*Hash;
    num%=HASH;
    hs[num]+=data;
}
inline LL Ask(LL x)
{
    unsigned LL num=x*Hash*Hash*Hash*Hash;
    num%=HASH;
    if (hs[num]>0) return 1;
    return 0;
}
inline LL read()
{
    LL nn=0; char cc=getchar();
    while (cc<'0' || cc>'9') cc=getchar();
    while (cc>='0' && cc<='9') nn=(nn<<3)+(nn<<1)+(cc^48),cc=getchar();
    return nn;
}

 

T2 主仆见证了 Hobo 的离别

　　咋说呢这题。。

　　考试的时候做了个笔记：动态开点权值线段树+树上合并。

　　然后我死了。

　　“正解”很简单，直接在线算，每次跑一遍Dfs暴力查找两个元素是否在同一条链上，居然能AC跑的还飞快。

　　其实真正的正解是离线算法，但我不会，只好水过了。

　　不得不说数据太水了。

　　小弟不才。

#include<cstdio>
#include<cstring>
#define HZOI std
using namespace HZOI;
const int N=5e6+3;
int n,m;
int dfn[N<<2],low[N<<2];
int tt,first[N<<2],vv[N<<3],nx[N<<3];
int Dfs(int ,int ,int );
inline void Add(int ,int );
inline int read();
int main()
{
    n=read(),m=read();
    for (int i=1,opt,a,b,c,d; i<=m; ++i)
    {
        opt=read(),a=read(),b=read();
        if (!opt)
        {
            ++n;
            if (b==1) { int x=read(); Add(x,n), Add(n,x); continue;}
            if (!a) for (int i=1,x; i<=b; ++i) Add(n,read());
            else for (int i=1,x; i<=b; ++i) Add(read(),n);
        }
        if (opt)
        {
            if (Dfs(a,0,b)) puts("1");
            else puts("0");
        }
    }
}
int Dfs(int k,int father,int goal)
{
    if (k==goal) return 1;
    for (int i=first[k]; i; i=nx[i])
    {
        int ver=vv[i];
        if (ver==father) continue;
        if (Dfs(ver,k,goal)) return 1;
    }
    return 0;
}
inline void Add(int u,int v)
{
    vv[++tt]=v,nx[tt]=first[u],first[u]=tt;
}
inline int read()
{
    int nn=0; char cc=getchar();
    while (cc<'0' || cc>'9') cc=getchar();
    while (cc>='0' && cc<='9') nn=(nn<<3)+(nn<<1)+(cc^48),cc=getchar();
    return nn;
}

 

T3 征途堆积出友情的永恒

　　这道题就有点水平了。

　　dp很好打，$dp_i=min(dp_j+max(b_j,sum_i-sum_j))$

　　含义不难理解，考虑优化。

　　我们发现$dp_j+b_j$是一个定值，所以我们只要选取其最小的就可以了，而$dp_j-sum_j+sum_i$随$i$单调递增，考虑用既然题目上都说了用堆优化，两个堆，一个维护$dp_i+b_i$，第二个维护$dp_i-sum_i$，然后乱搞就好了。

　　堆一的弹出条件：1.堆顶元素花费大于其位置为$sum$的花费 2.堆顶元素在范围内。

　　开搞，把堆一中元素弹走后，由二接受，然后就可以了，注意判断可行条件。

　　小弟不才。

　　

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=500005;
#define ll long long
int n,k;
ll  f[maxn],sum[maxn];
int a[maxn],b[maxn];
struct Binary_heap{
    ll top,heap[maxn],pn[maxn];
    int topp(){  return pn[1];  }
    void swap(ll &x,ll &y){ x^=y,y^=x,x^=y; }
    void up(int p){
        while(p>1){
            if(heap[p]<heap[p>>1])  swap(heap[p],heap[p>>1]),swap(pn[p],pn[p>>1]);
            else break;   p>>=1;
        }
    }
    void down(int p){
        int turn=p<<1;
        while(turn<=top){
            if(turn<top&&heap[turn]>heap[turn+1])  ++turn;
            if(heap[p]>heap[turn]) swap(heap[turn],heap[p]),swap(pn[p],pn[turn]);
            else break;    p=turn,turn<<=1;
        }
    }
    void insert(ll x,int y){heap[++top]=x; pn[top]=y; up(top); }
    void pop(){ heap[1]=heap[top]; pn[1]=pn[top--]; down(1); }
}fir,sec;
inline int read()
{    
    int t=0; char ch=getchar();    
    while(ch<'0'||ch>'9')  ch=getchar();
    while(ch>='0'&&ch<='9')  t=(t<<3)+(t<<1)+(ch^48),ch=getchar();
    return t;
}
int main()
{
    n=read(),k=read();
    for(register int i=1;i<=n;++i)  a[i]=read(),sum[i]=sum[i-1]+a[i];
    for(register int i=0;i<n;++i)  b[i]=read();
    ll tf,ts,turn;
    memset(f,0x7f,sizeof(f));
    f[0]=0;    
    fir.insert(b[0],0);
    for(register int i=1;i<=n;++i){
        turn=max(0,i-k);
        while(1){
            if(fir.top) tf=fir.topp(); else tf=-1;
            if(sec.top) ts=sec.topp();  else ts=-1;
            while(fir.top&&tf<turn) fir.pop(),tf=fir.topp();
            while(sec.top&&ts<turn) sec.pop(),ts=sec.topp();
            if(!fir.top)  tf=-1;  if(!sec.top)  ts=-1;
            if(ts!=-1&&(tf==-1||f[ts]-sum[ts]+sum[i]<f[tf]+b[tf])){
                f[i]=f[ts]-sum[ts]+sum[i]; break;
            }
            if(b[tf]>=sum[i]-sum[tf]){ f[i]=f[tf]+b[tf]; break; }
            while(fir.top&&b[tf]<sum[i]-sum[tf]){  sec.insert(f[tf]-sum[tf],tf),fir.pop(),tf=fir.topp(); }
        }
        fir.insert(f[i]+b[i],i);
    }
    printf("%lld",f[n]);
}