牛客练习赛45

A  QAQ:

dp[i][0]表示前i个字符可以组成的"Q",dp[i][1]表示前i个字符可以组成的"QA",dp[i][2]表示前i个字符可以组成的"QAQ"。扫一遍即可。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+10;
char t[5005];
ll dp[maxn][3];
int main()
{
    scanf("%s",t+1);
    int len=strlen(t+1);
    for(int i=1;i<=len;i++)
    {
        if(t[i]=='Q')
        {
            dp[i][0]=dp[i-1][0]+1;
            dp[i][1]=dp[i-1][1];
            if(i>1)
                dp[i][2]=dp[i-2][1]+dp[i-1][2];
            else
                dp[i][2]=dp[i-1][2];
        }
        else if(t[i]=='A')
        {
            dp[i][0]=dp[i-1][0];
            if(i>1)
                dp[i][1]=dp[i-2][0]+dp[i-1][1];
            else
                dp[i][1]=dp[i-1][1];
            dp[i][2]=dp[i-1][2];
        }
        else
        {
            dp[i][0]=dp[i-1][0];
            dp[i][1]=dp[i-1][1];
            dp[i][2]=dp[i-1][2];
        }
    }
    printf("%lld\n",dp[len][2]);
    return 0;
}

B  Tic-Tac-Toe:

暴力枚举

#include<bits/stdc++.h>
using namespace std;
char t[5][5],txt[5][5];
bool ok()
{
    for(int i=1;i<=3;i++)
    {
        bool flag=1;
        for(int j=1;j<=3;j++)
            if(txt[i][j]!='W')
                flag=0;
        if(flag)
            return 1;
        flag=1;
        for(int j=1;j<=3;j++)
            if(txt[j][i]!='W')
                flag=0;
        if(flag)
            return 1;
    }
    if(txt[1][1]=='W'&&txt[2][2]=='W'&&txt[3][3]=='W')
        return 1;
    if(txt[1][3]=='W'&&txt[2][2]=='W'&&txt[3][1]=='W')
        return 1;
    return 0;
}
bool cal()
{
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(txt[i][j]=='#')
            {
                txt[i][j]='W';
                if(ok())
                    return 1;
                txt[i][j]='#';
            }
        }
    }
    return 0;
}
bool check2()
{
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            if(t[i][j]=='W')
            {
                for(int i1=1;i1<=3;i1++)
                {
                    for(int j1=1;j1<=3;j1++)
                        txt[i1][j1]=t[i1][j1];
                }
                txt[i][j]='#';
                if(!cal())
                    return 1;
            }
        }
    }
    return 0;
}
bool check1()
{
    for(int i=1;i<=3;i++)
        for(int j=1;j<=3;j++)
            txt[i][j]=t[i][j];
    if(cal())
        return 0;
    else
        return 1;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        for(int i=1;i<=3;i++)
            scanf("%s",t[i]+1);
        if(check1())
            printf("Bob\n");
        else if(check2())
            printf("Emmm\n");
        else
            printf("Alice\n");
    }
    return 0;
}

C  Buy Fruits:

对于n为偶数的情况，例如n=10，发现按如下构造即可：

9,7,5,3,1,0,8,6,4,2

对于奇数的情况特判n==1，其他情况均为不可行

#include<bits/stdc++.h>
using namespace std;
int a[100005];
int main()
{
    int n;scanf("%d",&n);
    if(n==1)
        printf("0\n");
    else if(n%2)
        printf("-1\n");
    else
    {
        int x=n-1;
        for(int i=0;i<n/2;i++)
            a[i]=x,x-=2;
        a[n/2]=0;
        x=n-2;
        for(int i=n/2+1;i<=n;i++)
            a[i]=x,x-=2;
        for(int i=0;i<n;i++)
            printf("%d ",a[i]);
    }
}

D  Data Structure

先考虑没有询问，如何求得最大值呢。从高位到低位考虑，若这一位可取则取。是否可取只需要贪心的判断即可，可以从第一个数开始扫描，若扫描到当前的数时它们的或和已经包含了之前枚举的所有可取的位，则可以从此处断开，若最后分成了大于等于k段则是可行的。现在考虑修改操作，对于1操作，若x对应的二进制位是0则没有影响，否则全变为1，对于2操作，若x对应二进制位上为1没有影响，否则全变为0，所以一旦某一位产生了影响则在这之后这一位一定全为0或全为1，所以，一旦产生影响后把这一位单独拿出判断即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
int a[maxn],n,k,Q;
int vis[33];
bool check(int x,int p)
{
    int X=x|(1<<p);
    for(int i=30;i>=0;i--)
    {
        if(vis[i]==1&&(X>>i&1))
            X^=(1<<i);
        if(vis[i]==2&&(X>>i&1))
            return 0;
    }
    int cnt=0,ans=0;
    for(int i=1;i<=n;i++)
    {
        cnt|=a[i];
        if((cnt&X)==X)
        {
            cnt=0;
            ans++;
        }
    }
    return ans>=k;
}
int ask()
{
    int ans=0;
    for(int i=30;i>=0;i--)
        if(check(ans,i))
            ans^=(1<<i);
    return ans;
}
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    int ans=ask();
    scanf("%d",&Q);
    while(Q--)
    {
        int op,x;scanf("%d",&op);
        if(op==1)
        {
            scanf("%d",&x);
            for(int i=30;i>=0;i--)
            {
                if(x>>i&1)
                {
                    if(vis[i]==0)
                    {
                        vis[i]=1;
                        for(int j=1;j<=n;j++)
                            a[j]|=(1<<i);
                        ans=ask();
                    }
                    else
                    {
                        vis[i]=1;
                        ans|=(1<<i);
                    }
                }
            }
        }
        else if(op==2)
        {
            scanf("%d",&x);
            for(int i=30;i>=0;i--)
            {
                if(!(x>>i&1))
                {
                    if(vis[i]==0)
                    {
                        vis[i]=2;
                        for(int j=1;j<=n;j++)
                            if(a[j]>>i&1) a[j]^=(1<<i);
                        ans=ask();
                    }
                    else
                    {
                        vis[i]=2;
                        if(ans>>i&1)
                            ans^=(1<<i);
                    }
                }
            }
        }
        else
            printf("%d\n",ans);
    }
    return 0;
}
/*
3 1
3 5 4
33
3
1 2
3
2 5
3
1 1
3
*/

E   Pyramid

题解点这里

F Magic Slab

最大权闭合子图。若选了c[i][j]这个点，则a[i]和b[j]一定要选。考虑关联项，可以对于每一个关联项另外开辟一个节点，对于两个关联的节点分别加k,对新开辟的节点减去k,这样若两个关联节点只去了一个，一加一减刚好抵消，若两个都取了，则两次加一次减，相当于加了k,若两个点都不取则没有影响。

#include<bits/stdc++.h>
using namespace std;
const int maxn=20005;
const int inf=1e9;
struct node
{
    int to,cap,rev;
    node(int _to=0,int _cap=0,int _rev=0)
    {
        to=_to;
        cap=_cap;
        rev=_rev;
    }
};
vector<node>G[maxn];
int level[maxn],iter[maxn];
void add_edge(int from,int to,int cap)
{
    node e=node(to,cap,G[to].size());
    G[from].push_back(e);
    e=node(from,0,G[from].size()-1);
    G[to].push_back(e);
}

void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int v=que.front();que.pop();
        for(int i=0;i<G[v].size();i++)
        {
            node &e=G[v][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v,int t,int f)
{
    if(v==t)
        return f;
    for(int &i=iter[v];i<G[v].size();i++)
    {
        node &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t)
{
    int flow=0;
    while(1)
    {
        bfs(s);
        if(level[t]<0)
            return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0)
            flow+=f;
    }
    return flow;
}

int a[44],b[44],c[44][44],mp[20002];
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            scanf("%d",&c[i][j]);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
        scanf("%d",&b[i]);
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            sum+=c[i][j];
            int s=(i-1)*n+j;
            int t=n*n+i;
            mp[s]=c[i][j];
            add_edge(s,t,inf);
            t=n*n+n+j;
            add_edge(s,t,inf);
        }
        mp[n*n+i]=-a[i];
        mp[n*n+n+i]=-b[i];
    }
    for(int i=1;i<=m;i++)
    {
        int x1,y1,x2,y2,k;
        scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&k);
        add_edge((x1-1)*n+y1,n*n+2*n+i,inf);
        add_edge((x2-1)*n+y2,n*n+2*n+i,inf);
        mp[(x1-1)*n+y1]+=k;
        mp[(x2-1)*n+y2]+=k;
        mp[n*n+2*n+i]-=k;
        sum+=2*k;
    }
    int S=0,T=n*n+2*n+m+1;
    for(int i=1;i<T;i++)
    {
        if(mp[i]>0)
            add_edge(S,i,mp[i]);
        else
            add_edge(i,T,-mp[i]);
    }
    printf("%d\n",sum-max_flow(S,T));
    return 0;
}