Codeforces round #257 (Div. 2)

Question:

A jzzhu and children ------ codeforces created

B jzzhu and sequences ------ codeforces limit B

C jzzhu and chocolate ------ codeforces 449a

D jzzhu and cities ------ codeforces 449b

E jzzhu and apples ------ codeforces 449c

Question A: N numbers each time from front to back each number-m ask which number is finally reduced to 0 (water question)

#include<cstdio>#include<cstring>#include<algorithm>#include<queue>using namespace std;typedef __int64 LL;#define N 100010int n,m,ans;int main(){    int i,x,y;    scanf("%d%d",&n,&m);    for(i=1,y=-1;i<=n;i++)    {        scanf("%d",&x);        if(x/m+(x%m!=0)>=y)        {            y=x/m+(x%m!=0);            ans=i;        }    }    printf("%d\n",ans);    return 0;}

)

The recursive formula deformation Fi = fi-1-fi-2 can be introduced to the cycle of 6 and then directly calculated

#include<cstdio>#include<cstring>#include<algorithm>#include<queue>using namespace std;typedef __int64 LL;#define N 100010#define mod 1000000007LL x,y,n,ans;int main(){    scanf("%I64d%I64d%I64d",&x,&y,&n);    n%=6;    switch(n)    {        case 0: ans=x-y; break;        case 1: ans=x; break;        case 2: ans=y; break;        case 3: ans=y-x; break;        case 4: ans=-x; break;        case 5: ans=-y; break;    }    printf("%I64d\n",(ans%mod+mod)%mod);    return 0;}

Question C: Cut chocolate can only be cross-cut in the concave area or vertical cut ask N * m of chocolate cut K knife after the minimum block area can have the maximum size (IDEA)

First, if K is greater than N + m-2, the output must be-1.

Next, we will consider the Cutting Strategy. In order to maximize the minimum block size, we should try to divide it as few as possible.

That is to say, try to switch in one direction (either cross-cutting or vertical cutting)

Then we will start to discuss whether the K-knife can be cut off in one direction and determine whether it is cross-cutting or vertical cutting.

If the K-knife cannot be switched in one direction, both directions must be switched.

It is obvious that the long side should be cut first because the number of parts to be split is the least.

#include<cstdio>#include<cstring>#include<algorithm>using namespace std;typedef __int64 LL;LL n,m,k;int main(){    scanf("%I64d%I64d%I64d",&n,&m,&k);    if(n+m-2<k) printf("-1\n");    else if(n%(k+1)==0||m%(k+1)==0) printf("%I64d\n",n*m/(k+1));    else    {        if(n<m) swap(n,m);        if(m-1>=k) printf("%I64d\n",max(m/(k+1)*n,n/(k+1)*m));        else if(n-1>=k) printf("%I64d\n",n/(k+1)*m);        else printf("%I64d\n",m/(k-n+2));    }    return 0;}

D: there are highways and railways between N cities, each of which is bidirectional and the length of known railways must be from 1 city to a city. Now we need to delete as many railway lines as possible, but we need to keep 1 city to every the shortest path of a city remains unchanged. You can delete a maximum of several records (as shown in the figure below)

Because more railway lines need to be deleted, the road can be taken while the shortest path remains unchanged.

From this, the strategy is obtained. Starting from the first city, the shortest path is used to calculate the Shortest Path of the complete picture. At this time, the railway line in the shortest path cannot be deleted. calculate the number of deleted entries.

#include<cstdio>#include<cstring>#include<algorithm>#include<queue>using namespace std;typedef __int64 LL;#define N 100010int n,m,k,tot,ans;int vis[N],head[N],pre[N];LL dis[N];struct edge{    int v,w,kind,next;}ed[N*8];struct node{    int idx;    LL dis;    bool operator<(const node fa) const    {        return dis>fa.dis;    }}u,v;priority_queue<node> qu;void add(int u,int v,int w,int kind){    ed[tot].v=v;    ed[tot].w=w;    ed[tot].kind=kind;    ed[tot].next=head[u];    head[u]=tot++;}void bfs(){    int i;    u.dis=0; u.idx=1;    qu.push(u);    while(!qu.empty())    {        do        {            u=qu.top();            qu.pop();        }while(vis[u.idx]&&!qu.empty());        if(vis[u.idx]) return ;        vis[u.idx]=1;        if(pre[u.idx]!=-1) ans+=ed[pre[u.idx]].kind;        for(i=head[u.idx];~i;i=ed[i].next)        {            v.idx=ed[i].v;            v.dis=u.dis+ed[i].w;            if(!vis[v.idx])            {                if(dis[v.idx]==v.dis&&!ed[i].kind) pre[v.idx]=i;                if(!dis[v.idx]||dis[v.idx]>v.dis)                {                    pre[v.idx]=i;                    dis[v.idx]=v.dis;                    qu.push(v);                }            }        }    }}int main(){    int i,u,v,w;    memset(head,-1,sizeof(head));    memset(pre,-1,sizeof(pre));    scanf("%d%d%d",&n,&m,&k);    for(i=1;i<=m;i++)    {        scanf("%d%d%d",&u,&v,&w);        add(u,v,w,0);        add(v,u,w,0);    }    for(i=1;i<=k;i++)    {        scanf("%d%d",&v,&w);        add(1,v,w,1);    }    bfs();    printf("%d\n",k-ans);    return 0;}

Question E: numbers ranging from 1 to n are divided into groups. numbers in a group must be divided into groups. No matter how many groups can be divided and a solution can be provided)

Even numbers are the most friendly for us because all even numbers can be grouped into prime numbers in odd numbers, especially unfriendly.

Using the above idea, we can enumerate the prime number (not from 2 to 3) and find all the numbers containing the prime number of the factor.

In this case, if there are even numbers, you can directly group them in two groups.

If there is an odd number (but not one), we will discard an even number and then group them in two groups.

The remaining number is either the number of groups not found or the number of even groups. We can obtain the answer by grouping the even number into two groups.

#include<cstdio>#include<cstring>#include<algorithm>#include<vector>using namespace std;typedef __int64 LL;#define N 100010int n,cnt,ans;int flag[N],p[N],vis[N];vector< pair<int,int> > v;void get_prime(){    int i,j;    for(i=2;i<=n;i++)    {        if(!flag[i]) p[cnt++]=i;        for(j=0;j<cnt&&p[j]*i<=n;j++)        {            flag[i*p[j]]=1;            if(i%p[j]==0) break;        }    }}int main(){    int i,j,k;    scanf("%d",&n);    get_prime();    for(i=1;i<cnt;i++)    {        vector<int> tmp;        for(j=p[i];j<=n;j+=p[i])        {            if(!vis[j]) tmp.push_back(j);        }        k=tmp.size();        if(k==1) continue;        if(k%2==1)        {            for(vector<int>::iterator it=tmp.begin();it!=tmp.end();it++)            {                if(*it%2==0)                {                    tmp.erase(it);                    k--;                    break;                }            }        }        for(j=0;j<k;j+=2)        {            vis[tmp[j]]=1;            vis[tmp[j+1]]=1;            v.push_back(make_pair(tmp[j],tmp[j+1]));            ans++;        }    }    for(i=2,j=0;i<=n;i+=2)    {        if(!vis[i])        {            if(j)            {                v.push_back(make_pair(j,i));                ans++;                j=0;            }            else j=i;        }    }    printf("%d\n",ans);    for(i=0;i<ans;i++) printf("%d %d\n",v[i].first,v[i].second);    return 0;}

PS: I escaped from the competition yesterday. Today, I have to make up the problem. I have to spur myself to work harder !!!

Codeforces round #257 (Div. 2)