2016 ACM/ICPC Asia Regional Qingdao Online 青岛赛区（已完成8题）

1001

 

<pre name="code" class="cpp">#include <iostream>  
#include <cstdio>  
#define min(a,b) ((a)<(b)?(a):(b))  
#define min4(a,b,c,d) min(min(a,b),min(c,d))  
using namespace std;  
int a[5850];  


int bSearch(int begin, int end, int e)
{
    int mid, left = begin, right = end;
    while(left <= right){
        mid = (left + right) >> 1;
        if(a[mid] >= e) right = mid - 1;
        else left = mid + 1;
    }
    return left;
}


int main()  
{  
    freopen("input.txt","r",stdin);  
    int n=1, T;
    int p2,p3,p5,p7;  
    p2=p3=p5=p7=1;  
    a[1]=1;  
    while(n<5843){  
        a[++n]=min4(2*a[p2],3*a[p3],5*a[p5],7*a[p7]);
        if(a[n]==2*a[p2])p2++;
        if(a[n]==3*a[p3])p3++;  
        if(a[n]==5*a[p5])p5++;  
        if(a[n]==7*a[p7])p7++; 
    }  
    cin>>T;
    while(T--){
          scanf("%d",&n);
          printf("%d\n",a[bSearch(1,5842,n)]);
    }
    return 0;  
}  

 

 

1002

 

 

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn=300000+100;
double f[maxn];
char cmd[1500];
int main()
{
    for(int i=1;i<=110291;i++)
        f[i]=f[i-1]+1.0/pow(i,2);
    while(scanf("%s",cmd)!=EOF)
    {
        int ok=0;
        int n=0;
        for(int i=0;cmd[i];i++){
            if(cmd[i]-'0'!=0) ok=1;
            if(ok) n=n*10+cmd[i]-'0';
            if(n>110291) break;
        }
        if(n>110291) printf("1.64493\n");
        else printf("%.5f\n",f[n]);
    }
    return 0;
}

 

1003

 

这题超坑，卡常数卡了我两天。最后用数组写的AC自动机，指针版的AC自动机改了常数点还会超时，而且还会超空间。

很多题目常见的还是数组版AC自动机，指针版很少见，以后还是套数组的板子吧。

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=1000000+100;
char p[maxn];
int nxt[maxn][26],l[maxn],badnode[maxn],pre[maxn],vis[maxn];
int L,root;
int newnode(){
    for(int i=0;i<26;i++)
        nxt[L][i]=-1;
    l[L]=0;
    badnode[L++]=-1;
    return L-1;
}
void intial(){
    L=0;
    root=newnode();
}
void Insert(char *ss)
{
    int now=root;
    int len=(int)strlen(ss);
    for(int i=0;i<len;i++)
    {
        int idx=ss[i]-'a';
        if(nxt[now][idx]==-1)
            nxt[now][idx]=newnode();
        now=nxt[now][idx];
    }
    badnode[now]=1;
    l[now]=len;
}
void BuildDFA()
{
    queue<int> q;
    pre[root]=root;
    for(int i=0;i<26;i++){
        if(nxt[root][i]==-1)
            nxt[root][i]=root;
        else{
            pre[nxt[root][i]]=root;
            q.push(nxt[root][i]);
        }
    }
    while(!q.empty())
    {
        int now=q.front();q.pop();
        for(int i=0;i<26;i++)
        {
            if(nxt[now][i]==-1)
                nxt[now][i]=nxt[pre[now]][i];
            else{
                pre[nxt[now][i]]=nxt[pre[now]][i];
                q.push(nxt[now][i]);
            }
        }
    }
}
void work()
{
    memset(vis,0,sizeof(vis));
    int now=root;
    int len=(int)strlen(p);
    for(int i=0;i<len;i++)
    {
        int idx=0;
        if(p[i]>='A'&&p[i]<='Z') idx=p[i]-'A';
        else if(p[i]>='a'&&p[i]<='z') idx=p[i]-'a';
        else continue;
        now=nxt[now][idx];
        int cur=now;
        while(cur!=root)
        {
            if(badnode[cur]!=-1)
            {
                vis[i+1]--;
                vis[i-l[cur]+1]++;
                break;
            }
            
            cur=pre[cur];
        }
    }
    long long ans=0;
    for(int i=0;i<len;i++)
    {
        ans+=vis[i];
        if(ans>0) printf("*");
        else printf("%c",p[i]);
    }
    printf("\n");
}
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        intial();
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%s",p);
            Insert(p);
        }
        BuildDFA();
        getchar();
        gets(p);
        work();
    }
    return 0;
}

 

 

 

 

 

1005

 

 

#include<stdio.h>
int main()
{
    int n,t;
    scanf("%d",&t);
    for(;t>0;t--)
    {
        scanf("%d",&n);
        if(n%2)
            printf("Balanced\n");
        else
            printf("Bad\n");
    }
    return 0; 
}

 

1006

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=100000+10;
int n,m;
int degree[maxn],val[maxn];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        int u,v;
        memset(degree,0,sizeof(degree));
        for(int i=1;i<=n;i++) scanf("%d",&val[i]);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
//            if(u==v) continue;
            degree[u]++;
            degree[v]++;
        }
        int s=0,e=0;
        int cnt=0;
        for(int i=1;i<=n;i++)
        {
            if((degree[i])&1) cnt++;
            if(cnt>2) break;
            if(degree[i]&1&&s==0) s=i;
            else if(degree[i]&1&&s!=0) e=i;
        }
        if(cnt>2||cnt==1) {printf("Impossible\n");continue;}
        int ans=0;
        if(cnt==2) {
            ans=ans^val[s];ans=ans^val[e];
            for(int i=1;i<=n;i++){
                if(degree[i]/2%2==1) ans=ans^val[i];
            }
        }
        else{
            int Max=0;
            for(int i=1;i<=n;i++){
                if(degree[i]/2%2==1) ans=ans^val[i];
            }
            int sum=ans;
            for(int i=1;i<=n;i++){
                if(degree[i]/2%2==1) Max=max(Max,sum^val[i]);
            }
            ans=Max;
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

1007

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
const int maxn=200000+100;
int val[maxn];
int n;
ll T;
bool merge(int k)
{
    ll ans=0;
    int head=1,tail=n;
    queue<ll> q;
    if(k!=1&&(n-1)%(k-1)!=0){
        for(int i=1;i<=(n-1)%(k-1)+1;i++)
            ans+=val[i];
        head=(n-1)%(k-1)+2;
        q.push(ans);
    }
    while(head<=tail||!q.empty())
    {
        int sum=0;
        for(int i=0;i<k;i++)
        {
            if(head<=tail&&!q.empty()&&val[head]<q.front()) {sum+=val[head++];}
            else if(!q.empty()&&head<=tail&&q.front()<=val[head]) {sum+=q.front();q.pop();}
            else if(q.empty()) {sum+=val[head++];}
            else if(head>tail) {sum+=q.front();q.pop();}
        }
        ans+=sum;
        if(ans>T) break;
        q.push(sum);
        if(q.size()==1&&head>tail) break;
    }
    return ans>T?false:true;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%lld",&n,&T);
        for(int i=1;i<=n;i++) scanf("%d",&val[i]);
        sort(val+1,val+1+n);
        int k=0;
        int l=1,r=n;
        while(l<r)
        {
            k=(l+r)/2;
            if(merge(k)) r=k;
            else l=k+1;
        }
        printf("%d\n",l);
    }
    return 0;
}

 

 

 

 

 

 

1010

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=100+10;
typedef long long ll;
ll w[maxn],v[maxn];
ll r[maxn];
ll n,k;
ll ans,t;
int cmp(const int i,const int j) {return (double)v[i]/w[i]>(double)v[j]/w[j];}
bool check(int i,ll sw,ll sv)
{
    for(int j=i;j<k&&sw<t;j++)
    {
        ll idx=r[j];
        if(sw+w[idx]<=t) sw+=w[idx],sv+=v[idx];
        else sv+=(double)v[idx]/w[idx]*(t-sw),sw=t;//最优性剪枝
    }
    return sv>ans;
}
void dfs(int i,ll sw,ll sv)
{
    ans=max(ans,sv);
    if(i<k&&check(i,sw,sv))
    {
        ll idx=r[i];
        if(sw+w[idx]<=t) dfs(i+1,sw+w[idx],sv+v[idx]);
        dfs(i+1,sw,sv);
    }
}
int main()
{
    while(scanf("%lld%lld",&n,&t)!=EOF)
    {
        ans=0;k=0;
        for(int i=0;i<n;i++)
        {
            ll x,y;
            scanf("%lld%lld",&x,&y);
            if(x<=t){
                w[k]=x;v[k]=y;
                r[k]=k;k++;
            }
        }
        sort(r,r+k,cmp);
        dfs(0,0,0);
        printf("%lld\n",ans);
    }
    return 0;
}

 

1011

这题目完全是最短路和最小割的模版。

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int maxn=1000+10;
struct edge{
    int v,w,next;
}edge[maxn*10];
struct node{
    int v,cap,rev;
    node(int v,int cap,int rev): v(v),cap(cap),rev(rev) {}
};
int n,m;
int tot;
int head[maxn],dist[maxn],vis[maxn];
vector<node> G[maxn];
void add_edge(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
    
    edge[tot].v=u;
    edge[tot].w=w;
    edge[tot].next=head[v];
    head[v]=tot++;
}
void spfa(int s)
{
    memset(dist,0x7f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    dist[s]=0;
    vis[s]=1;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].next){
            int v=edge[i].v;
            if(dist[v]==dist[u]+1&&!vis[v]){
                vis[v]=1;
                q.push(v);
            }
            if(dist[v]>dist[u]+1){
                dist[v]=dist[u]+1;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
void add(int u,int v,int cap)
{
    G[u].push_back(node(v,cap,(int)G[v].size()));
    G[v].push_back(node(u,0,(int)G[u].size()-1));
}
void Build_Graph()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j!=-1;j=edge[j].next)
        {
            int v=edge[j].v;
            int w=edge[j].w;
            if(dist[v]-dist[i]==1){
                add(i,v,w);
            }
        }
    }
}
int dfs(int u,int t,int f)
{
    if(u==t) return f;
    vis[u]=1;
    for(int i=0;i<G[u].size();i++)
    {
        node &e=G[u][i];
        if(!vis[e.v]&&e.cap>0)
        {
            int d=dfs(e.v,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.v][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int Dinic()
{
    int ans=0;
    while(1)
    {
        memset(vis,0,sizeof(vis));
        int f=dfs(1,n,99999999);
        if(f==0) break;
        ans+=f;
    }
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        tot=0;
        memset(head,-1,sizeof(head));
        for(int i=1;i<=n;i++) G[i].clear();
        int u,v,w;
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
        }
        spfa(1);
        Build_Graph();
        printf("%d\n",Dinic());
    }
    return 0;
}