ACM Amman Collegiate Programming Contest(7.22随机组队娱乐赛)

题目链接 https://vjudge.net/contest/240074#overview

只写一下自己做的几个题吧

/*
D n^2的暴力dp怎么搞都可以的
这里先预处理 i到j的串时候合法
转移的时候枚举上一个状态 O1判断
*/
#include<cstdio>
#include<cstring>
#include<iostream>
#define maxn 1010
using namespace std;
int T,n,m,f[maxn],g[maxn][maxn];
char s[maxn];
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        scanf("%s",s+);
        int p,ok;
        memset(g,,sizeof(g));
        for(int i=;i<=n;i++){
            ok=;p=;
            for(int j=i+;j<=n;j++){
                if(s[j]==s[i])p++;
                else p--;
                if(s[j]==s[j-])ok=;
                if((j-i+)&){
                    if(p==&&ok==)g[i][j]=;
                }
                else{
                    if(p==&&ok==)g[i][j]=;
                }
            }
        }
        memset(f,/,sizeof(f));f[]=;
        for(int i=;i<=n;i++){
            for(int j=i-m;j<i;j++)
                if(j>=&&g[j+][i]==)
                    f[i]=min(f[i],f[j]+);
        }
        printf("%d\n",f[n]-);
    }
    return ;
}
/*
n小的很 直接暴力枚举选不选的每种情况
在此之前 从大到小排一遍序
就可以避免把司机当成智障的情况了

*/
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int T,n,s,a[],ans;
int cmp(int x,int y){
    return x>y;
}
void Dfs(int now,int sum,int cnt){
    if(sum>=s){
        ans=max(ans,cnt);return;
    }
    if(now==n+){
        if(sum>=s)ans=max(ans,cnt);
        return;
    }
    Dfs(now+,sum+a[now],cnt+);
    Dfs(now+,sum,cnt);
}
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&s);
        for(int i=;i<=n;i++)
            scanf("%d",&a[i]);
        sort(a+,a++n,cmp);
        ans=;Dfs(,,);
        printf("%d\n",ans);
    }
    return ;
}
/*
思路应该是找到直径,连成环
emmmmm图的直径不会找....
那就 先缩点,弄成树 然后找一下直径
缩完点之后边数就是桥的个数
*/
#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#define maxn 200010
using namespace std;
int T,n,m,num,head[maxn],dfn[maxn],low[maxn];
int s[maxn],top,f[maxn],topt,bl[maxn];
int Head[maxn],N;
queue<int>q;
struct node{
    int v,pre;
}e[maxn],p[maxn];
int init(){
    int x=,f=;char s=getchar();
    while(s<''||s>''){if(s=='-')f=-;s=getchar();}
    while(s>=''&&s<=''){x=x*+s-'';s=getchar();}
    return x*f;
}
void Memset(){
    memset(head,,sizeof(head));
    memset(dfn,,sizeof(dfn));
    memset(low,,sizeof(low));
    memset(s,,sizeof(s));
    memset(f,,sizeof(f));
    memset(bl,,sizeof(bl));
    memset(Head,,sizeof(Head));
    N=;num=;top=;topt=;N=;
}
void Add(int from,int to){
    num++;e[num].v=to;
    e[num].pre=head[from];
    head[from]=num;
}
void Ad(int from,int to){
    num++;p[num].v=to;
    p[num].pre=Head[from];
    Head[from]=num;
}
void Tarjan(int u,int from){
    dfn[u]=low[u]=++topt;
    s[++top]=u;f[u]=;
    for(int i=head[u];i;i=e[i].pre){
        int v=e[i].v;
        if(v==from)continue;
        if(dfn[v]==){
            Tarjan(v,u);low[u]=min(low[u],low[v]);
        }
        else if(f[v])low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        N++;while(s[top]!=u){
            f[s[top]]=;bl[s[top]]=N;top--;
        }
        f[s[top]]=;bl[s[top]]=N;top--;
    }
}
int Bfs(int S){
    memset(f,,sizeof(f));
    memset(s,,sizeof(s));
    f[S]=;q.push(S);
    while(!q.empty()){
        int k=q.front();q.pop();
        for(int i=Head[k];i;i=p[i].pre){
            int v=p[i].v;
            if(f[v])continue;
            f[v]=;q.push(v);s[v]=s[k]+;
        }
    }
    int mx=,V=S;
    for(int i=;i<=N;i++)
        if(mx<s[i]){
            mx=s[i];V=i;
        }
    return V;
}
int Bf(int S){
    memset(f,,sizeof(f));
    memset(s,,sizeof(s));
    f[S]=;q.push(S);
    while(!q.empty()){
        int k=q.front();q.pop();
        for(int i=Head[k];i;i=p[i].pre){
            int v=p[i].v;
            if(f[v])continue;
            f[v]=;q.push(v);s[v]=s[k]+;
        }
    }
    int mx=;
    for(int i=;i<=N;i++)
        mx=max(mx,s[i]);
    return mx;
}
int main(){
    T=init();
    while(T--){
        n=init();m=init();int u,v;
        Memset();
        for(int i=;i<=m;i++){
            u=init();v=init();
            Add(u,v);Add(v,u);
        }
        for(int i=;i<=n;i++)
            if(dfn[i]==)Tarjan(i,);
        num=;for(u=;u<=n;u++)
            for(int i=head[u];i;i=e[i].pre){
                v=e[i].v;
                if(bl[u]==bl[v])continue;
                Ad(bl[u],bl[v]);
            }
        int S=Bfs();
        printf("%d\n",num/-Bf(S));
    }
    return ;
}
/*
I
一开始一直不知道从那下手 只是想到某些点应该固定了
只改一次值 但是并没有找到是那些点
好吧挺简单的就是第一个点 (寄几太弱)
如果我们确定了最后的数都输 X 并且操作的区间长度是K
那么第一个数只可能通过操作 1-k这个区间来搞
同理往后推 就找到了下一个只改一次的点
在以这个点为起点往后重复上述操作
最后检查剩下的点是不X就好啦
然后算一下 T*10*N*N*N
哎呀 GG
一开始想能不能把枚举K的那个N二分优化成log
然后发现不单调
这就很明显了 优化的是最后那个n*n
一开始无脑套线段树T成智障
第二天看题解有这么一句 :
some contestants used segment tree to do it and got tle.....
delete  再见
考虑每次往后修改k个数 每个+C的过程慢了
我们维护一个sum 代表累积到这里需要加几
然后这个区间完事之后剪掉
搞成On 优雅
*/
#include<cstdio>
#include<cstring>
using namespace std;
int T,n,k,sub[];
char s[],ss[];
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%s",ss+);
        n=strlen(ss+);int ok=;
        for(k=n;k>=;k--){
            for(char fir='';fir<='';fir++){
                for(int i=;i<=n;i++)s[i]=ss[i];
                memset(sub,,sizeof(sub));
                int falg=,sum=,c;
                for(int i=;i+k-<=n;i++){
                    sum-=sub[i];
                    s[i]=(s[i]-''+sum)%+'';
                    c=(fir-s[i]+)%;
                    sum+=c;s[i]=fir;sub[i+k]+=c;
                }
                for(int i=n-k+;i<=n;i++){
                    sum-=sub[i];
                    s[i]=(s[i]-''+sum)%+'';
                }
                for(int i=;i<n;i++)
                    if(s[i]!=s[i+]){
                        falg=;break;
                    }
                if(falg==){
                    ok=;printf("%d\n",k);break;
                }
            }
            if(ok)break;
        }
    }
    return ;
}
/*
D题的加强版 需要优化
按照D题的思路 对于每个i 在i-k - i-1 中选一个最优的且合法
的状态转移过来 最优这件事可以用数据结构优化
但是是不是合法 就要在研究研究
我们到这思考 想要这个题可做 那i的上一个状态一定是从一段连续
的区间里选  我们这次转移新构造的串是 j-i 这一块
而题目不合法的串是010101这样子的
倘若出现了00 或 11 后面不论加什么(长度合法)都是合法的串串
这就很巧妙地迎合了我们的设想
i-k 011010100101010 i-1 i
下面我们考虑 维护隔得i最近的还是最远的 00 11
(这里一开始脑子GG了 wa到挺)
我们选择上一个状态的左区间一定是i-k 最优的情况下
肯定是 右区间越靠右越好 那我们就找 离得i最近的00 11
这个东西预处理一下 存在dis里面
然后我这个代码写的有点丑了 左边界老是取不好
我就直接把1-k的区间预处理了一下
*/
#include<cstdio>
#include<iostream>
#define maxn 400010
#define lc k*2
#define rc k*2+1
#define mid (l+r)/2
using namespace std;
int T,n,k,dis[maxn],f[maxn],s[maxn];
char S[maxn];
void Insert(int k,int l,int r,int x,int y){
    if(l==x&&r==x){
        s[k]=y;return;
    }
    if(x<=mid)Insert(lc,l,mid,x,y);
    else Insert(rc,mid+,r,x,y);
    s[k]=min(s[lc],s[rc]);
}
int Query(int k,int l,int r,int x,int y){
    if(x<=l&&y>=r)return s[k];
    int ret=1e9;
    if(x<=mid)ret=min(ret,Query(lc,l,mid,x,y));
    if(y>mid)ret=min(ret,Query(rc,mid+,r,x,y));
    return ret;
}
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%s",&n,&k,S+);
        for(int i=;i<=n*;i++){
            s[i]=1e9;f[i]=1e9;
        }
        int pos=;
        for(int i=;i<=n;i++){
            if(S[i]==S[i-])pos=i-;
            dis[i]=pos;
        }
        int falg=;f[]=;
        Insert(,,n,,);
        for(int i=;i<=k;i++){
            if(S[i]==S[i-])falg=;
            if(falg)f[i]=;
            else f[i]=i;
            Insert(,,n,i,f[i]);
        }
        for(int i=k+;i<=n;i++){
            if(dis[i]<i-k)f[i]=f[i-]+;
            else f[i]=Query(,,n,i-k,dis[i])+;
            Insert(,,n,i,f[i]);
        }
        printf("%d\n",f[n]-);
    }
    return ;
}