Codeforces Round #592 (Div. 2) A,B,C,D,E

题目：A. Pens and Pencils

 

题意思路：略

 

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int q,a,b,c,d,k;
    cin>>q;
    while(q--){
        cin>>a>>b>>c>>d>>k;
        bool flag=false;
        int ans1=0,ans2=0;
        for (int i=1;i<=k;i++){
            if (i*c>=a&&(k-i)*d>=b){
                ans1=i;
                ans2=(k-i);
                flag=true;
                break;
            }
        }
        if (flag)
            cout<<ans1<<" "<<ans2<<endl;
        else
            cout<<"-1"<<endl;
    }
    return 0;
}

 

 

题目：B. Rooms and Staircases

 

题意：

　　　　旅馆存在两楼，每层楼的房间数都为n，0代表该房间门口无楼梯，1代表有楼梯

　　       问小明从任意房间出发，一个房间只能路过一次，求可以路过房间的数量    的最大值

 

思路：

1.从第一层最左端点出发，找离的最远的楼梯上去，再返会到第二层最左端   路过的房间数记录下来

2.从第一层最右端点出发，找离的最远的楼梯上去，再返回到第二层最右端   路过的房间数记录下来

　　上述两者取最大值输出即可。

 

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
char str[1010];
bool vis[5][1010];
int main()
{
    int q,n;
    cin>>q;
    while (q--){
        cin>>n>>str+1;
        int tmp=-1,ans=n;
        for (int i=1;i<=n;i++){
            if (str[i]=='1'){
                tmp=i;
                break;
            }
        }
        if (tmp!=-1)
            ans=max(ans,(n-tmp+1)*2);
        for (int i=n;i>=1;i--){
            if (str[i]=='1'){
                tmp=i;
                break;
            }
        }
        if (tmp!=-1)
            ans=max(ans,(tmp*2));
        cout<<ans<<endl;
    }
    return 0;
}

 

题目：C. The Football Season

题意：

　　已知整数   n，p，w，d

　　其中    n是游戏总局数，p是总得分，赢了得w分，平局得d分

　　求    x，y，z值，     分别为赢的局数，平的局数，输的局数

　　　　显然满足以下方程

　　　　　　x*w+y*d=p

　　　　　　x+y+z=n

 　　若存在xyz，则输出x，y，z值，不存在则输出-1

 

思路：

　　先看一下数据范围  d (1≤n≤1e12,0≤p≤1e17,1≤d<w≤1e5)，如果用线性的算法的话，只能围绕d和w。

　　x*w+y*d=p      变形------>    x= (p-d*y)%w         ,然后根据取余规律，x的范围在【0，w-1】，即【0,1e5-1】;然后直接暴力了。

 

#include<iostream>
typedef long long ll;
using namespace std;
int main()
{
    ll n,p,w,d,x,y,z;
    cin>>n>>p>>w>>d;
    bool flag=false;
    for (int i=0;i<w;i++){
        if ((p-(d*i))%w==0&&(p-(d*i))/w+i<=n&&p>=d*i){
            x=(p-(d*i))/w;
            y=i;
            z=n-x-y;
            flag=true;break;
        }
    }
    if (flag){
        cout<<x<<" "<<y<<" "<<z<<endl;
    }
    else
        cout<<-1<<endl;
    return 0;
}

 

D. Paint the Tree

 

题意：

　　有三种颜色，要给n个点进行涂色，不同结点涂不同颜色，具有不同花费，问在任意连续的直接相连的三个结点之间不存在同种颜色的情况下，求最小花费

思路：

　　从入度为1的点出发（如果存在入度大于2的点，就直接输出-1），然后分六种情况，

　　分别是12，13，21，23，31，32  （23的意思是第一个结点涂颜色2，二块涂颜色3，后面如果不想连续三个结点之间重复颜色的点，必定是231循环涂色）

　　六种情况取涂色花费最小值即可。

 

#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll a[4][100004];
vector <ll> v[100004];
ll t[6][3]={{1,2,3},{1,3,2},{2,1,3},{2,3,1},{3,1,2},{3,2,1}};
ll ans[6];
ll lans[6][100004];
void dfs (ll i,ll j,ll k,ll count){
    ll temp=count%3;
    ans[k]+=a[t[k][temp]][i];
    lans[k][i]=t[k][temp];
    for (ll m=0;m<v[i].size();m++)
    {
        if (v[i][m]!=j)
        {
            dfs(v[i][m],i,k,count+1);
        }
    }
}
int main(){
    ll n;
    cin>>n;
    memset(ans,0,sizeof(ans));
    for (ll i=1;i<=3;i++){
        for (ll j=1;j<=n;j++){
            cin>>a[i][j];
        }
    }
    for (ll i=0;i<n-1;i++)
    {
        ll c,d;
        cin>>c>>d;
        v[c].push_back(d);
        v[d].push_back(c);
    }
    ll leaf;
    for (ll i=1;i<=n;i++)
    {
        if (v[i].size()>2)
        {
            cout<<-1;
            exit(0);
        }
        if (v[i].size()==1)
            leaf=i;
    }
    ll ans_min=1e18;
    ll ind;
    for (ll i=0;i<6;i++)
    {
        dfs(leaf,-1,i,0);
        // cout<<ans[i]<<" ";
        if (ans[i]<ans_min)
        {
            ans_min=ans[i];
            ind=i;
        }
    }
    cout<<ans[ind]<<endl;
    for (ll i=1;i<=n;i++)
        cout<<lans[ind][i]<<" ";
}

 

 

E. Minimizing Difference

 

题意：

　　　给你n个数，最多k次操作（操作次数可以小于k），每次操作只能让一个数+1或者-1，问　　该数组的最大值 - 该数组的最小值       最小为多少

 

思路：

　　　先排序一下，然后只需要对最小值进行+1，最大值进行-1。  

　　问题只需要解决什么时候进行+1，什么时候进行-1。

　　只需要看最小值的数量和最大值的数量谁更少，若最小值的数量少，则所以最小值+1，反之最大值-1。（其实就是看谁的操作次数少能让max-min的值可以改变）

 

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
 
const int MAXN=1e5+10;
struct Node{
    ll a,cnt;
}mp[MAXN],bt[MAXN];
bool cmp(const Node&a,const Node&b){
    if (a.a!=b.a)
        return a.a<b.a;
}
ll n,k;
int main(){
    scanf("%lld%lld",&n,&k);
    for (int i=1;i<=n;i++){
        scanf("%lld",&mp[i].a);
        mp[i].cnt=0;
    }    
    sort(mp+1,mp+n+1,cmp);
    ll L=1,R=1,tmp=1;
    for (int i=2;i<=n;i++){
        if (mp[i].a==mp[i-1].a){
            tmp++;
        }
        else if (mp[i].a!=mp[i-1].a){            
            bt[R].cnt=tmp;
            bt[R].a=mp[i-1].a;
            R++;
            tmp=1;
        }
        if (i==n){
            bt[R].cnt=tmp;
            bt[R].a=mp[i].a;
        }
    }
    ll ans=bt[R].a-bt[L].a;
//    cout<<ans<<endl;
    while(k>0&&L<R){
        if (bt[L].cnt>bt[R].cnt){
            if (k<bt[R].cnt)
                break;
            if (k>=bt[R].cnt*(bt[R].a-bt[R-1].a)){
                k-=bt[R].cnt*(bt[R].a-bt[R-1].a);
                R--;
                bt[R].cnt+=bt[R+1].cnt;
                ans=min(ans,bt[R].a-bt[L].a);                
            }
            else{
                ll tmp=k/bt[R].cnt;
                k-=bt[R].cnt*tmp;
                bt[R].a-=tmp;
                ans=min(ans,bt[R].a-bt[L].a);
            }
        }
        else{
            if (k<bt[L].cnt)
                break;
            if (k>=bt[L].cnt*(bt[L+1].a-bt[L].a)){
                k-=bt[L].cnt*(bt[L+1].a-bt[L].a);
                L++;
                bt[L].cnt+=bt[L-1].cnt;
                ans=min(ans,bt[R].a-bt[L].a);             
            }
            else{
                ll tmp=k/bt[L].cnt;
                k-=tmp*bt[L].cnt;
                bt[L].a+=tmp;
                ans=min(ans,bt[R].a-bt[L].a);
            }
        }        
    }
    cout<<ans<<endl;
    return 0;
}