Codeforces Contest 1141 Round #547题解：想法，dfs

AK拉，虽然div3也没什么好骄傲的。。

由于题面过长，就直接发链接：this way

A. Game 23

题意：

给你两个数，问你第一个数要几次只乘2或者3达到第二个数，不能输出-1.

题解：

先判断b%a是否等于0（这里忘判了wa了一发），之后只需要后一个数除前一个数看看是否能被若干个2,3除到1。

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    if(b%a!=0)
        return 0*printf("-1\n");
    b/=a;
    int cnt=0;
    while(b%2==0)
        b/=2,cnt++;
    while(b%3==0)
        b/=3,cnt++;
    printf("%d\n",b==1?cnt:-1);
    return 0;
}

B. Maximal Continuous Rest

题意：

给你一个数组只包含0和1，这个数组重复无数次，问你最多有多少个连在一起的1。

题解：

那么只需要比较前缀1和后缀1加在一起和这个串里最长的连续1的长度即可。

#include<bits/stdc++.h>
using namespace std;
int a[200005];
int main()
{
    int pre=0,suf=0;
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
        if(a[i]!=1)
            break;
        else
            pre++;
    for(int i=n;i>1;i--)
        if(a[i]!=1)
            break;
        else
            suf++;
    int mx=0,sum=0;
    for(int i=1;i<=n;i++)
        if(a[i]==0)
            mx=max(mx,sum),sum=0;
        else
            sum++;
    printf("%d\n",max(mx,pre+suf));
    return 0;
}

C. Polycarp Restores Permutation

题意：

给你一个数组，他表示的是第i个数和第i+1个数的差值，问你还原这n个数后，是否可能是1到n的某种排列。

题解：

我们可以假设我们知道第一个数，然后for一遍，我们记录每个数是否出现过以及这些数的最大最小值，如果没有重复的数且最大值-最小值<n的话，就是1到n的某种排列。

#include<bits/stdc++.h>
using namespace std;
int vis[2000005],a[200005];
int main()
{
    int n,x,up=5e5,down=5e5;
    scanf("%d",&n);
    int pre=5e5,flag=0;
    a[1]=pre;
    vis[pre]=1;
    for(int i=2;i<=n;i++)
    {
        scanf("%d",&x);
        if(flag)
            continue;
        if(vis[pre+x]||up-down>=n)
            flag=1;
        pre+=x;
        up=max(up,pre),down=min(down,pre);
        vis[pre]=1;
        a[i]=pre;
    }
    if(flag||up-down>=n)
        return 0*printf("-1\n");
    for(int i=1;i<=n;i++)
        printf("%d%c",a[i]-down+1,i==n?'\n':' ');
    return 0;
}

D. Colored Boots

题意：

给你两个字符串，左边与右边字符串中相同的两个字符可以分成一组，?可以和任何字符分成一组，每个字符只能用一次，问你最多能分成多少组。

题解：

那我们只需要记录没种字符出现的位置，之后for几遍找a与b的一一对应即可。

#include<bits/stdc++.h>
using namespace std;
#define pa pair<int,int>
queue<int>l[300],r[300];
vector<pa>vec;
int main()
{
    int n;
    scanf("%d",&n);
    char s[200005],ss[200005];
    scanf("%s%s",s+1,ss+1);
    for(int i=1;i<=n;i++)
        l[s[i]].push(i);
    for(int i=1;i<=n;i++)
        r[ss[i]].push(i);
    for(int i='a';i<='z';i++)
    {
        while(l[i].size()&&r[i].size())
            vec.push_back({l[i].front(),r[i].front()}),l[i].pop(),r[i].pop();
    }
    char i='?';
    for(int j='a';j<='z';j++)
    {
        while(l[i].size()&&r[j].size())
            vec.push_back({l[i].front(),r[j].front()}),l[i].pop(),r[j].pop();
        while(l[j].size()&&r[i].size())
            vec.push_back({l[j].front(),r[i].front()}),l[j].pop(),r[i].pop();
    }
    while(l['?'].size()&&r['?'].size())
        vec.push_back({l['?'].front(),r['?'].front()}),l['?'].pop(),r['?'].pop();
    printf("%d\n",vec.size());
    for(int i=0;i<vec.size();i++)
        printf("%d %d\n",vec[i].first,vec[i].second);
    return 0;
}

E. Superhero Battle

题意：

有n个英雄要打败一只怪兽，在每个时间点之后，怪兽的血量就会增加a[i]，如此循环，问你要过多少时间这只怪兽才会死，不可能输出-1。

题解：

当第一轮杀不死且每一轮结束之后怪兽的血都没有扣，那么就不可能杀死怪兽。判掉这两种情况之后，我们记录在一轮中扣的血量的最大值，因为不一定是一轮之后这只怪兽才会死的，所以我们先把前面几轮直接用除法算出来，在最后一轮的时候for一遍即可。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll a[200005];
int main()
{
    ll h,n,minn=0;
    scanf("%lld%lld",&h,&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i]),a[i]+=a[i-1],minn=min(minn,a[i]);
    for(int i=1;i<=n;i++)
        if(a[i]<=-h)
            return 0*printf("%d\n",i);
    if(a[n]>=0)
        return 0*printf("-1\n");
    ll m=(h+minn-a[n]-1)/(-a[n]);
    h=h-m*(-a[n]);
    for(ll i=1;i<=n;i++)
        if(a[i]<=-h)
            return 0*printf("%lld\n",m*n+i);
}

F1. Same Sum Blocks (Easy)

题意：

给你一个数组，让你从中挑几段，使得这几段的和都一样，并且段数最多，n<=50.

题解：

对于easy和hard当然有不同的做法，这个的话当然是直接暴力枚举所有可能（所有可能是指枚举所有的区间，他们的和的可能性），在每次找的时候贪心的找结尾最前面的那一段，为什么可以贪心？因为如果有两种方法都可以得到相同的数，那么结尾在后面的肯定不如结尾在前面的，因为你取了这一段，后面是没法再用前面的内容，那么结尾肯定是越早越好，因为后面的数还有可能可以让后面的段取。

#include<bits/stdc++.h>
using namespace std;
set<int>st;
int a[55],ans[55][2],aa[55][2];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        int s=0;
        for(int j=i;j>=1;j--)
            s+=a[j],st.insert(s);
    }
    for(int i=1;i<=n;i++)
        a[i]+=a[i-1];
    int mx=0;
    for(set<int>::iterator it=st.begin();it!=st.end();it++)
    {
        int s=0,cnt=0,pre=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=i;j>pre;j--)
            {
                if(a[i]-a[j-1]==*it)
                {
                    aa[++cnt][0]=j,aa[cnt][1]=i;
                    pre=i;
                    break;
                }
            }
        }
        if(cnt>mx)
        {
            mx=cnt;
            for(int i=1;i<=mx;i++)
                ans[i][0]=aa[i][0],ans[i][1]=aa[i][1];
        }
    }
    printf("%d\n",mx);
    for(int i=1;i<=mx;i++)
        printf("%d %d\n",ans[i][0],ans[i][1]);
    return 0;
}

F2. Same Sum Blocks (Hard)

题意：

给你一个数组，让你从中挑几段，使得这几段的和都一样，并且段数最多，n<=1500

题解：

对于hard的情况，我想到的是我们既然是取段最多的情况，那我们也像刚才一样枚举所有区间的可能，但是这次不是枚举开头，而是直接枚举区间和。我们首先处理所有区间和的可能性，把所有的l，r放到对应的map里面，之后枚举map，对于每种和的可能都做一遍，同样也是每次都取结尾最小的情况。这样就是n*n*log的复杂度。

#include<bits/stdc++.h>
using namespace std;
#define pa pair<int,int>
struct node
{
    int f,e;
    bool operator< (const node& a)const
    {
        return e<a.e;
    }
};
unordered_map<int,vector<node> >mp;
int a[2005];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        int s=0;
        for(int j=i;j>=1;j--)
            s+=a[j],mp[s].push_back({j,i});
    }
    int ans=0,mx=0;
    for(unordered_map<int,vector<node> >::iterator it=mp.begin();it!=mp.end();it++)
    {
        if(it->second.size()<=mx)
            continue;
        sort(it->second.begin(),it->second.end());
        int siz=it->second.size();
        int pre=0,cnt=0;
        for(int i=0;i<siz;i++)
            if(it->second[i].f<=pre)
                continue;
            else
                cnt++,pre=it->second[i].e;
        if(cnt>mx)
            mx=cnt,ans=it->first;
    }
    printf("%d\n",mx);
    int pre=0;
    for(int i=0;i<mp[ans].size();i++)
    {
        if(mp[ans][i].f<=pre)
            continue;
        else
            printf("%d %d\n",mp[ans][i].f,mp[ans][i].e),pre=mp[ans][i].e;
    }
    return 0;
}

G. Privatization of Roads in Treeland

题意：

给你一个国家的图，这个国家有很多城市和道路连接不同的城市，这张图是一棵树，它的每条边都要让某个公司承包，但是如果某个公司承包了两条及以上的某个城市的边，那么这座城市被认为是不公平的，让你找出最少需要多少个公司，使得这个国家不公平的城市小于等于k个。

题解：

这不是一道水题么，，为什么是2500分。首先我们记录每座城市有多少条边连着，之后sort一下，那么第con[n-k]个城市连的边就是最少需要公司的数量，因为这样就可以保证大于公司数量的边的城市不会超过k个。之后我们dfs一遍这棵树，如果这个点连的边数>num[n-k]，就让它的所有边为1，（因为这样比较简单）否则就从小到大枚举公司，但是不能和父亲传过来的边所承包的公司相同，所以我们dfs的时候就再加一个参数代表父亲传过来的边的值。

#include<bits/stdc++.h>
using namespace std;
#define pa pair<int,int>
const int N=2e5+5;
struct node
{
    int to,next;
}e[N*2];
int head[N],cnt;
void add(int x,int y)
{
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}
int con[N],a[N],mx;
map<pa,int>Id;
int ans[N];
void dfs(int x,int fa,int col)
{
    int cnt=1;
    for(int i=head[x];~i;i=e[i].next)
    {
        int ne=e[i].to;
        if(ne==fa)
            continue;
        if(cnt==col)
            cnt++;
        if(con[x]>mx)
            ans[Id[{ne,x}]]=1,dfs(ne,x,1);
        else
            ans[Id[{ne,x}]]=cnt,dfs(ne,x,cnt),cnt++;
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    int n,k;
    scanf("%d%d",&n,&k);
    int x,y;
    for(int i=1;i<n;i++)
        scanf("%d%d",&x,&y),add(x,y),add(y,x),con[x]++,con[y]++,a[x]=con[x],a[y]=con[y],Id[{x,y}]=Id[{y,x}]=i;
    sort(a+1,a+1+n);
    mx=a[n-k];
    dfs(1,0,0);
    printf("%d\n",mx);
    for(int i=1;i<n;i++)
        printf("%d%c",ans[i],i==n-1?'\n':' ');
    return 0;
}