11.5 两次考试

上午

题还是比较水的...

T1 attack

题意：

给一个有向图，Q次询问K个点，问从1到K个点的必经点 (没说是DAG，但数据是DAG...)、

支配树的裸题吗，但是不会支配树啊....

然后就求割点，桥，然后就懵逼了....

DAG上支配树直接增量构造就好了

有环的还不会...

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}
const int N=100006;
int first[N],ver[N<<1],nt[N<<1],e;
void addb(int u,int v)
{
    ver[e]=v;
    nt[e]=first[u];
    first[u]=e++;
}
struct FAN
{
    int first[N],ver[N<<1],nt[N<<1],e;
    void clear()
    {
        e=0; mem(first,-1);
    }
    void addb(int u,int v)
    {
        ver[e]=v;
        nt[e]=first[u];
        first[u]=e++;
    }
}h[2];

int n,m,Q,K;
int maxk;
int deg[N];

int fa[N],dep[N],st[N][21];
int LCA(int x,int y)
{
    if(dep[x]<dep[y]) x^=y,y^=x,x^=y;
    int j;
    for(j=maxk;~j;--j)
        if(dep[x]-(1<<j)>=dep[y])
            x=st[x][j];
    if(x==y) return x;
    for(j=maxk;~j;--j)
        if(st[x][j]!=-1&&st[x][j]!=st[y][j])
            x=st[x][j],y=st[y][j];
    return fa[x];
}
void match(int x,int y)
{
    fa[x]=y; dep[x]=dep[y]+1; st[x][0]=y;
    int j;
    for(j=1;j<=maxk&&st[x][j-1]!=-1;++j)
        st[x][j]=st[st[x][j-1]][j-1];
}

int dui[N<<2],he,en;
void build()
{
    while((1<<maxk)<=n) ++maxk; --maxk;
    mem(st,-1); fa[1]=-1;
    he=1; en=0;
    dui[++en]=1;
    int now,ve,las; rint i;
    while(en>=he)
    {
        now=dui[he++]; las=0;
        for(i=h[0].first[now];i!=-1;i=h[0].nt[i])
        {
            ve=h[0].ver[i];
            if(las)
                las=LCA(las,ve);
            else
                las=ve;
        }
        if(las)
            match(now,las);
        for(i=first[now];i!=-1;i=nt[i])
        {
            --deg[ver[i]];
            if(!deg[ver[i]])
                dui[++en]=ver[i];
        }
    }
}

void work()
{
    rint i,j; int tin,las;
    for(i=1;i<=Q;++i)
    {
        read(K); las=0;
        for(j=1;j<=K;++j)
        {
            read(tin);
            if(las)
                las=LCA(las,tin);
            else
                las=tin;
        }
        printf("%d\n",dep[las]+1);
    }
}

int main(){

    rint i; int tin1,tin2;
    mem(first,-1); h[1].clear(); h[0].clear();

    read(n); read(m); read(Q);
    for(i=1;i<=m;++i)
    {
        read(tin1); read(tin2);
        ++deg[tin2];
        addb(tin1,tin2);
        h[0].addb(tin2,tin1);
    }
    build();
    work();
}

T1

T2 reverse

大水题，模拟就行了

我用了双取模...

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
#define ull unsigned long long
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}
const int P1=76543;
const int P2=1000003;
const int LEN=5006;

int T;
int lena,lenb;
int la,ra,fa,lb,rb,fb;
char A[LEN],B[LEN];
ull prea1[LEN],sufa1[LEN],prea2[LEN],sufa2[LEN];
ull preb1[LEN],sufb1[LEN],preb2[LEN],sufb2[LEN];
ull PP1[LEN],PP2[LEN];

void rota()
{
    if(fa)
    {
        if(A[la]==‘A‘)
            ++la;
        else
            ++la,fa^=1;
    }
    else
    {
        if(A[ra]==‘A‘)
            --ra;
        else
            --ra,fa^=1;
    }
    --lena;
}

void rotb()
{
    if(fb)
    {
        if(B[lb]==‘A‘)
            ++lb;
        else
            ++lb,fb^=1;
    }
    else
    {
        if(B[rb]==‘A‘)
            --rb;
        else
            --rb,fb^=1;
    }
    --lenb;
}

int check()
{
    ull haa1,haa2,hab1,hab2;
    if(fa)
    {
        haa1=(sufa1[la]-sufa1[ra+1]*PP1[ra-la+1]);
        haa2=(sufa2[la]-sufa2[ra+1]*PP2[ra-la+1]);
    }
    else
    {
        haa1=(prea1[ra]-prea1[la-1]*PP1[ra-la+1]);
        haa2=(prea2[ra]-prea2[la-1]*PP2[ra-la+1]);
    }
    if(fb)
    {
        hab1=(sufb1[lb]-sufb1[rb+1]*PP1[rb-lb+1]);
        hab2=(sufb2[lb]-sufb2[rb+1]*PP2[rb-lb+1]);
    }
    else
    {
        hab1=(preb1[rb]-preb1[lb-1]*PP1[rb-lb+1]);
        hab2=(preb2[rb]-preb2[lb-1]*PP2[rb-lb+1]);
    }
    if(haa1==hab1&&haa2==hab2)
        return 1;
    return 0;
}

void prin()
{
    rint i;
    if(fa)
    {
        for(i=ra;i>=la;--i)
            printf("%c",A[i]);
    }
    else
    {
        for(i=la;i<=ra;++i)
            printf("%c",A[i]);
    }

    printf("\n");

    /*if(fb)
    {
        for(i=rb;i>=lb;--i)
            printf("%c",B[i]);
    }
    else
    {
        for(i=lb;i<=rb;++i)
            printf("%c",B[i]);
    }
    printf("\n");*/
}

void work()
{
    rint i; int len;
    fa=fb=0; la=lb=1; ra=lena; rb=lenb;
    for(i=lena;i;--i) A[i]=A[i-1]; A[0]=0;
    for(i=lenb;i;--i) B[i]=B[i-1]; B[0]=0;

    /*printf("\n");
    for(i=1;i<=lena;++i)
        printf("%c",A[i]);
    printf("\n");*/

    for(i=1;i<=lena;++i)
        prea1[i]=(prea1[i-1]+A[i])*P1,
        prea2[i]=(prea2[i-1]+A[i])*P2;
    for(i=1;i<=lenb;++i)
        preb1[i]=(preb1[i-1]+B[i])*P1,
        preb2[i]=(preb2[i-1]+B[i])*P2;
    for(i=lena;i;--i)
        sufa1[i]=(sufa1[i+1]+A[i])*P1,
        sufa2[i]=(sufa2[i+1]+A[i])*P2;
    for(i=lenb;i;--i)
        sufb1[i]=(sufb1[i+1]+B[i])*P1,
        sufb2[i]=(sufb2[i+1]+B[i])*P2;
    while(lena>lenb) rota();
    while(lenb>lena) rotb();

    //prin();

    len=lena;
    for(i=len;i;--i)
    {
        if(check())
        {
            prin();
            return ;
        }
        rota(); rotb();
    }
    puts("-1");
}

int main(){

    //freopen("T2.in","r",stdin);

    //freopen("reverse.in","r",stdin);
    //freopen("reverse.out","w",stdout);

    rint i;
    PP1[0]=PP2[0]=1;
    for(i=1;i<LEN;++i)
        PP1[i]=PP1[i-1]*P1,
        PP2[i]=PP2[i-1]*P2;

    read(T);
    while(T--)
    {
        mem(A,0); mem(B,0);
        mem(prea1,0); mem(prea2,0); mem(sufa1,0); mem(sufa2,0);
        mem(preb1,0); mem(preb2,0); mem(sufb1,0); mem(sufb2,0);
        scanf("%s%s",A,B);
        lena=strlen(A); lenb=strlen(B);
        work();
    }
}

T2

T3 tree

原题

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define dd double
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}
const int N=100006;
int first[N],nt[N<<1],ver[N<<1],e;
void addb(int u,int v)
{
    ver[e]=v;
    nt[e]=first[u];
    first[u]=e++;
}

int n,maxk;
ll sumg[N],f[N],g[N];

int fa[N];//dep[N];
void dfs1(int x)
{
    f[x]=1;
    int i;
    for(i=first[x];i!=-1;i=nt[i])
        if(ver[i]!=fa[x])
        {
            fa[ver[i]]=x;
            //dep[ver[i]]=dep[x]+1;
            dfs1(ver[i]);
            f[x]+=f[ver[i]]+1;
        }
}
void dfs2(int x)
{
    if(fa[x]!=-1)
        sumg[x]=sumg[fa[x]];
    sumg[x]+=g[x];
    int i;
    for(i=first[x];i!=-1;i=nt[i])
        if(ver[i]!=fa[x])
        {
            if(fa[x]!=-1)
                g[ver[i]]=g[x]+1;
            g[ver[i]]+=(1+f[x]-(f[ver[i]]+1)-1);
            dfs2(ver[i]);
        }
}

int main(){

    //freopen("T3.in","r",stdin);
    //freopen("T3.out","w",stdout);

    //freopen("tree.in","r",stdin);
    //freopen("tree.out","w",stdout);

    rint i; int tin1,tin2;
    mem(first,-1);

    read(n);
    for(i=1;i<n;++i)
    {
        read(tin1); read(tin2);
        addb(tin1,tin2);
        addb(tin2,tin1);
    }
    fa[1]=-1; dfs1(1);
    dfs2(1);

    for(i=1;i<=n;++i)
        printf("%lld.000\n",sumg[i]+1);
}

T3

下午

T1 入阵曲

$O(n^3)$枚举，打个时间戳

ans忘开long long了...30分

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
//#include <ctime>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}
const int N=1000006;

int n,m,mod;
int sum[406][406];
int tim[N],timer,cnt[N];
ll ans;

int main(){

    //freopen("T1.in","r",stdin);
    //freopen("T1.out","w",stdout);

    //freopen("rally.in","r",stdin);
    //freopen("rally.out","w",stdout);

    rint i,j,l,r; rint tt;

    read(n); read(m); read(mod);
    for(i=1;i<=n;++i)
        for(j=1;j<=m;++j)
        {
            read(tt);
            sum[i][j]=(sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+tt+mod)%mod;
        }
    for(l=1;l<=m;++l)
        for(r=l;r<=m;++r)
        {
            ++timer;
            tim[0]=timer; cnt[0]=1;
            for(i=1;i<=n;++i)
            {
                tt=(sum[i][r]-sum[i][l-1]+mod)%mod;
                if(tim[tt]==timer)
                    ans+=cnt[tt],++cnt[tt];
                else
                    tim[tt]=timer,cnt[tt]=1;
            }
        }
    printf("%lld\n",ans);
//    printf("\n%d\n",clock());
}

T1

T2 将军令

poi火药那个题的削弱版

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}
const int N=100006;
int first[N],ver[N<<1],nt[N<<1],e;
void addb(int u,int v)
{
    ver[e]=v;
    nt[e]=first[u];
    first[u]=e++;
}

int n,K,op;
int ans;

int d[N],le[N],fa[N];
void dfs(int x)
{
    d[x]=0;
    int i;
    for(i=first[x];i!=-1;i=nt[i])
        if(ver[i]!=fa[x])
        {
            fa[ver[i]]=x;
            dfs(ver[i]);
            if(d[ver[i]]!=-1&&d[x]<d[ver[i]]+1)
                d[x]=d[ver[i]]+1;
            if(le[ver[i]]!=-1&&le[x]<le[ver[i]]-1)
                le[x]=le[ver[i]]-1;
        }
    if(le[x]>=d[x])
        d[x]=-1;
    if(d[x]==K)
    {
        d[x]=-1;
        ++ans;
        le[x]=K;
    }
}

int main(){

    //freopen("T2.in","r",stdin);
    //freopen("general.in","r",stdin);
    //freopen("general.out","w",stdout);

    rint i; int tin1,tin2;
    mem(first,-1);

    read(n); read(K); read(op);
    for(i=1;i<n;++i)
    {
        read(tin1); read(tin2);
        addb(tin1,tin2);
        addb(tin2,tin1);
    }

    mem(le,-1); mem(d,-1);
    dfs(1);
    if(d[1]!=-1) ++ans;
    printf("%d\n",ans);
}

T2

T3 星空

考试打的傻dp骗了80  2333333

先说说考试的傻dp吧

用背包dp预处理出$g_len$表示len这么长都覆盖一次需要的最小次数 (也可以bfs求拉)

$f_i$ 表示前i个原先没亮的点都点亮，并且其他原先亮着的点也亮着 $f[8]$

转移：

找出连续的一段，枚举往左往右到哪，然后转移

找出下一段连续的一段，这两段同时被点亮，转移

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}

int n,K,m;
int len[106],pos[106];
int g[80006];
int f[106];

void work12()
{
    rint i; int ans=0;
    if(len[m]==1)
        ans=K;
    else
    {
        if(m==2)
        {
            for(i=1;i<=K;)
            {
                if(pos[i]==pos[i+1]-1)
                    ++ans,i+=2;
                else
                    ++ans,++i;
            }
        }
        else
        {
            for(i=1;i<=K;i+=2)
              ans+=(pos[i+1]-pos[i]);
        }
    }
    printf("%d\n",ans);
}

void work200()
{
    rint i,j,k; int l1,r1,l2,r2,tt;
    mem(g,30);
    g[0]=0;
    for(i=1;i<=m;++i)
        for(j=n;j>=len[i];--j)
            if(g[j]>g[j-len[i]]+1)
                g[j]=g[j-len[i]]+1;
    mem(f,30); f[0]=0;
    pos[K+1]=n+1;
    for(i=1;i<=K;++i)
    {
        l1=i; r1=l1+1; while(r1<=K&&pos[r1]==pos[r1-1]+1) ++r1; --r1;
        l2=r1+1; r2=l2+1; while(r2<=K&&pos[r2]==pos[r2-1]+1) ++r2; --r2;
        for(j=pos[l1];j>pos[l1-1];--j)
            for(k=pos[r1];k<pos[r1+1];++k)
            {
                tt=g[k-j+1]+g[pos[l1]-j]+g[k-pos[r1]];
                if(f[r1]>f[l1-1]+tt) f[r1]=f[l1-1]+tt;
            }
        if(l2<=K)
        {
            tt=g[pos[r2]-pos[l1]+1]+g[pos[l2]-pos[r1]-1];
            if(f[r2]>tt+f[l1-1]) f[r2]=tt+f[l1-1];
            tt=g[pos[l2]-pos[l1]]+g[pos[r2]-pos[r1]];
            if(f[r2]>tt+f[l1-1]) f[r2]=tt+f[l1-1];
        }
    }
    if(f[K]>100000) f[K]=K+m;
    printf("%d\n",f[K]);
}

void work4e4()
{
    rint i,j,k; int l1,r1,l2,r2,tt;
    mem(g,30);
    g[0]=0;
    for(i=1;i<=m;++i)
        for(j=n;j>=len[i];--j)
            if(g[j]>g[j-len[i]]+1)
                g[j]=g[j-len[i]]+1;
    mem(f,30); f[0]=0;
    pos[K+1]=n+1; int ci;
    for(i=1;i<=K;++i)
    {
        l1=i; r1=l1+1; while(r1<=K&&pos[r1]==pos[r1-1]+1) ++r1; --r1;
        l2=r1+1; r2=l2+1; while(r2<=K&&pos[r2]==pos[r2-1]+1) ++r2; --r2;
        ci=0;
        for(j=pos[l1];j>pos[l1-1];--j)
        {
            ++ci; if(ci>60) break;
            for(k=pos[r1];k<pos[r1+1];++k)
            {
                tt=g[k-j+1]+g[pos[l1]-j]+g[k-pos[r1]];
                if(f[r1]>f[l1-1]+tt) f[r1]=f[l1-1]+tt;
            }
        }
        ci=0;
        for(k=pos[r1];k<pos[r1+1];++k)
        {
            ++ci; if(ci>60) break;
            for(j=pos[l1];j>pos[l1-1];--j)
            {
                tt=g[k-j+1]+g[pos[l1]-j]+g[k-pos[r1]];
                if(f[r1]>f[l1-1]+tt) f[r1]=f[l1-1]+tt;
            }
        }
        if(l2<=K)
        {
            tt=g[pos[r2]-pos[l1]+1]+g[pos[l2]-pos[r1]-1];
            if(f[r2]>tt+f[l1-1]) f[r2]=tt+f[l1-1];
            tt=g[pos[l2]-pos[l1]]+g[pos[r2]-pos[r1]];
            if(f[r2]>tt+f[l1-1]) f[r2]=tt+f[l1-1];
        }
    }
    if(f[K]>100000) f[K]=K+m;
    printf("%d\n",f[K]);
}

int main(){

    //freopen("T3.in","r",stdin);

    //freopen("starlit.in","r",stdin);
    //freopen("starlit.out","w",stdout);

    rint i;

    read(n); read(K); read(m);
    for(i=1;i<=K;++i)
        read(pos[i]);
    sort(pos+1,pos+1+K);
    for(i=1;i<=m;++i)
        read(len[i]);
    sort(len+1,len+1+m);
    if(len[m]<=2)
        work12();
    else
        if(n<=200)
            work200();
    else
        work4e4();
}

T3傻dp

正解

设$A_i$表示原序列，规定1是灭，0是亮

$B_i$是一个差分数组，$B_i=A_{i} ^ A_{i+1}$

问题转化成 不超过$2*K$个1，两两配对，问最小花费和

那么bfs预处理出来从一个1到另一个1的最小步数

然后状压就行了

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define rint register int
using namespace std;
inline void read(int &x)
{
    x=0; int ff=1; char q=getchar();
    while(q<‘0‘||q>‘9‘) { if(q==‘-‘) ff=-1; q=getchar(); }
    while(q>=‘0‘&&q<=‘9‘) x=x*10+q-‘0‘,q=getchar();
    x*=ff;
}

int n,K,m,maxp;
int len[106];
int t[106],con;
int A[40006],g[40006];
int dis[36][36];

int dui[300006],he,en;
void get(int pp)
{
    mem(g,30);
    g[pp]=0; he=1; en=0;
    dui[++en]=pp;
    int i,now;
    while(en>=he)
    {
        now=dui[he++];
        for(i=1;i<=m;++i)
        {
            if(now-len[i]>=0&&g[now-len[i]]>g[now]+1)
            {
                g[now-len[i]]=g[now]+1;
                dui[++en]=now-len[i];
            }
            if(now+len[i]<=n&&g[now+len[i]]>g[now]+1)
            {
                g[now+len[i]]=g[now]+1;
                dui[++en]=now+len[i];
            }
        }
    }
}

void bfs()
{
    rint i,j;
    for(i=1;i<=con;++i)
    {
        get(t[i]);
        for(j=1;j<=con;++j)
            dis[i][j]=g[t[j]];
    }
}

int f[(1<<16)+100];
int dp()
{
    maxp=(1<<con)-1;
    mem(f,30); f[maxp]=0;
    rint i,j,k;
    for(i=maxp;~i;--i)
        for(j=1;j<=con;++j)
            for(k=j+1;k<=con;++k)
                if( ((1<<(j-1))&i) && ((1<<(k-1))&i) && f[i^(1<<(j-1))^(1<<(k-1))]>f[i]+dis[j][k] )
                    f[i^(1<<(j-1))^(1<<(k-1))]=f[i]+dis[j][k];
    return f[0];
}

int main(){

    //freopen("T3.in","r",stdin);

    rint i; int tin;

    read(n); read(K); read(m);
    for(i=1;i<=K;++i)
        read(tin),A[tin]=1;
    for(i=1;i<=m;++i)
        read(len[i]);
    for(i=0;i<=n;++i)
        if( A[i]^A[i+1] )
            t[++con]=i;

    bfs();
    printf("%d\n",dp());
}

T3正解

时间： 2024-11-12 20:32:55

11.5 两次考试的相关文章

苏宁智慧零售燃爆，818发烧节成比肩阿里双11的两大消费高峰

家电品类开售10分钟订单即破46亿.全渠道订单量实现155%的增长,APP购物活跃用户数同比增长97%,47分钟内销售额超过2015年同期全天的记录!2018年8月18日深夜,当本届"苏宁818发烧节"成绩单公布出来的时候,向来以严格著称的苏宁掌舵人张近东也显得感性起来,在庆功宴上他给公司25万员工们的辛勤工作下了个结论:"这是一份令人激动的成绩单.". 超高速的业绩增长让张近东和他的员工们信心百倍,而在消费者们眼里,这次"818发烧节"给他们带

spark 笔记 11: SchedulingAlgorithm 两种调度算法的优先级比较

调度算法的最基本工作之一,就是比较两个可执行的task的优先级.spark提供的FIFO和FAIR的优先级比较在SchedulingAlgorithm这个接口体现. FIFO: --计算优先级的差.注意,在程序中,大部分时候是优先级的数字越小,它优先级越高 --如果优先级相同,那么stage编号越靠前,优先级越高 --如果优先级字段和stage id都相同,那么s2比s1更优先.(有这种情况?) FAIR: --没有达到最小资源的task比已经达到最小资源的task优先级高 --如果两个task

1.11判断两个无环单链表是否相交

判断两个无环单链表是否交叉 题目描述: 如上图,这两个链表相交于结点5,要求判断两个链表是否相交,如果相交,找出相交处的结点. 解题思路: 方法一:Hash 法 如上图所示,如果两个链表相交,那么它们一定会有公共的结点,由于结点的地址或引用可以作为结点的唯一标识,因此,可以通过判断两个链表中的结点是否有相同的地址或引用来判断链表是否相交. 方法二:首尾相接法 将这两个链表首尾相连(例如把链表headl尾结点链接到head2的头指针),然后检测这个链表是否存在环,如果存在,则两个链表相交,而环入口

2019.11.11~2019.11.12考试总结

这两天又考了两次试,现总结一下这两次的情况. 11.11场 开场先读题,T1感觉有点大,T2感觉不可做,T3没有思路.确定按顺序做题.先开T1,仿佛是个2-sat,先写了一会儿,发现浪费算法,然后发现T1是个模拟,不如直接写if分类讨论,1.5h左右写完并调完此题.然后开T2,3.4操作一眼打标记,不知道怎么维护1.2操作,只能打一个线段树,没过样例,查了一下错,发现没判边界,补了上去,就过样例了,重新看了一遍代码,感觉问题不大,就开T3了,时间只剩40min.T3开始读错题了,写了一个暴力发现

RHCE(7.0)考试题目解析

前期准备: systemctl set-default graphical.target reboot 或者systemctl isolate graphical.target驱动图形化 ifconfig查看IP地址 cat /etc/resolv.conf查看DNS hostname查看主机名 systemctl stop iptables systemctl disable iptables systemctl mask iptables systemctl stop ebtables sy

[补档][HNOI 2008]GT考试

题目 阿申准备报名参加GT考试,准考证号为N位数X1X2....Xn(0<=Xi<=9),他不希望准考证号上出现不吉利的数字. 他的不吉利数学A1A2...Am(0<=Ai<=9)有M位,不出现是指X1X2...Xn中没有恰好一段等于A1A2...Am. A1和X1可以为0 INPUT 第一行输入N,M,K.接下来一行输入M位的数. N<=10^9,M<=20,K<=1000 OUTPUT 阿申想知道不出现不吉利数字的号码有多少种,输出模K取余的结果. SAMPL

frm考试

风险管理涵盖众多领域,包括风险管理概论.数量分析.金融市场与金融产.定价与风险模型.市场风险测度与管理.信用风险测度与管理.操作风险测度与管理.基金投资风险.会计.法律等众多内容.在今日错综复杂.瞬 息万变的金融市场上,风险往往难以掌握.有效管理风险并从中获取利润成为金融企业成功的重要关键.而这一攸关企业组织及其投资人命运的重要决策,需要众多 的金融风险管理专业人士(Financial Risk Professionals)的参与,故FRM日益受到重视,全球报考人数以每年超过38%成长,已俨然成

职业经理人常犯的11种错误-余世维

★课程提纲 ——通过本课程,您能学到什么? 第一讲 拒绝承担个人责任 1． 引言 2．          有效的管理者,为事情的结果负责 3．          “努力的表现”与“不停的辩解” 4．          观察你自己,别光是观察市场/管区/办公室/人手 第二讲 未能启发工作人员 1．          引言 2．          离开办公室一天,不会引发混乱 3．          主管需要“少不了他们”的感觉 4．          未能自己训练员工,提升其绩效 5．     

最新 CKA 考试指南及注意事项来啦～

最近有许多社区的同学私信问我,有关 CKA 考试的各种问题,鉴于 2019 年就快到了,小编决定写一篇最全 Certified Kubernetes Administrator 考试指南,助大家备战 2019. 什么是 CKA? CKA 就是 Kubernetes 管理员(CKA)认证计划,由 CNCF 与 Linux 基金会合作创立,旨在助力 Kubernetes 生态系统发展. CKA 有什么用? CKA 是 CNCF 致力于发展 Kubernetes 管理员社区,进而促进公司和组织广泛使用