Educational Codeforces Round 59 (Rated for Div. 2)

A. Digits Sequence Dividing

题意:给你一个长度300的,只由1-9构成的字符串,问你是否能按顺序分成至少2部分,满足每个数都比前一个数大

题解:由于没有0,所以拆分后的数,只要满足位数比你多,就一定能完成.

        对于长度为2的单独判断,其他的直接分成2段:第一位和剩下所有

#include<bits/stdc++.h>
using namespace std;
int T,n;
char s[305];
int main()
{
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        scanf("%s",s+1);
        if (n==2)
        {
            if (s[1]>=s[2]) printf("NO\n");else
            printf("YES\n2\n%c %c\n",s[1],s[2]);
        }else
        {
            printf("YES\n2\n%c ",s[1]);
            for (int i=2;i<=n;i++) printf("%c",s[i]);
            printf("\n");
        }
    }
} 

 

B. Digital root

题意:定义s(x)等于x的每一位之和的s(),直到小于10,例如s(38)=s(3+8)=s(11)=s(1+1)=s(2),

        现在给你多组k,x,问你满足s(n)=x的数中第k大的是多少

题解:动手写写s(10)=1,s(11)=2,s(18)=9,s(19)=1,s(20)=2,s(27)=9,s(28)=1

        显然发现9个一循环,所以答案就是(k-1)*9+x 

#include<bits/stdc++.h>
using namespace std;
int T;
long long n,m;
int main()
{
    scanf("%d",&T);
    while (T--)
    {
        scanf("%lld%lld",&n,&m);
        printf("%lld\n",(n-1)*9+m);
    }
} 

 

C. Brutality

题意:给你一个2e5的只有小写字母的字符串,每个字母都有一个权值,再给你一个K,表示连续相同的字符最多只能取k个

       例如 k=3的时候,aaaa只能最多选择3个连续的进行选择,问最多能得到的权值是多少

题意:对于每段相同的字母,排序后找最大的k个,贪心选择一下就好了

#include<bits/stdc++.h>
using namespace std;
int n,k;
long long ans,a[200005];
char s[200005];
int main()
{
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    scanf("%s",s+1);
    for (int i=1,j=1;i<=n;i=j)
    {
        while (j<=n && s[i]==s[j]) j++;
        sort(a+i,a+j);
        int p=max(j-k,i);
        for (int t=j-1;t>=p;t--) ans+=a[t];
    } 
    printf("%lld",ans);
} 

 

D. Compression

题意:给一个n*n(n<=5200)的01矩阵,问你能不能分成(n/x) * (n/x)的矩阵若干个,使得每个矩阵内部都是0或者都是1,问你最大x是多少

题解:从大到小枚举到x,暴力判断每个子矩阵是否一样,感觉并太好卡暴力,因为要保证一个较小的x是答案,数据会在x更大的更快退出

#include<bits/stdc++.h>
using namespace std;
int n,ans;
char a[5202];
string t[520500];
int dfs(int x)
{
    for(int i=0;i<n;i+=x)
    for(int j=0;j<n;j+=x)
    {    
        char ch=t[i][j];
        for(int k=i;k<i+x;k++)
        for(int p=j;p<j+x;p++) if(t[k][p]!=ch) return 0;
    }
    return 1;
}
int main()
{
    scanf("%d",&n);
    for (int i=0;i<n;i++)
    {
        string a;
        cin>>a;
        //scanf("%s",a+1);
        int len=a.size();
        for (int j=0;j<len;j++)
        {
            if(a[j]=='0') t[i]+="0000";
            if(a[j]=='1') t[i]+="0001";
            if(a[j]=='2') t[i]+="0010";
            if(a[j]=='3') t[i]+="0011";
            if(a[j]=='4') t[i]+="0100";
            if(a[j]=='5') t[i]+="0101";
            if(a[j]=='6') t[i]+="0110";
            if(a[j]=='7') t[i]+="0111";
            if(a[j]=='8') t[i]+="1000";
            if(a[j]=='9') t[i]+="1001";
            if(a[j]=='A') t[i]+="1010";
            if(a[j]=='B') t[i]+="1011";
            if(a[j]=='C') t[i]+="1100";
            if(a[j]=='D') t[i]+="1101";
            if(a[j]=='E') t[i]+="1110";
            if(a[j]=='F') t[i]+="1111";
        }
    }
    for (int i=n;i>=1;i--)
    {
        if (n%i==0)
            if (dfs(i)) {ans=i;break;}
    }
    printf("%d",ans);
}

 

E. Vasya and Binary String

题意:给你一个长度100的01字符串,每次可以选连续相同的任意个字符消除,消除后两边的字符接上去,

        消去一个长度的字符串会得到一个收益,问消除完所有的能得到的最大收益是多少

题解:典型的区间dp,dp[i][j][k]表示删除从i到j的字符串,该子串前k位和第一位一样的时候,消除的收益

        2种转移:直接消除这k个 dp[i][j][k]=a[k]+dp[i+1][j][1]

                     消除中间的,让前后连起来再消除 dp[i][j][k]=dp[i+1][q-1][1]+dp[q][j][k+1](s[q]==s[i])

         答案就是dp[1][n][1]

#include<bits/stdc++.h>
#define lld long long 
#define N 102
using namespace std;
lld a[N],f[N][N][N];
char s[N];
int n;
lld why(int st,int ed,int p)
{
    if (st>ed) return 0;
    if (f[st][ed][p]!=-1) return f[st][ed][p];
    if (st==ed)
    {
        f[st][ed][p]=a[p];
        return f[st][ed][p];
    }
    f[st][ed][p]=a[p]+why(st+1,ed,1);
    for (int i=st+1;i<=ed;i++)
        if (s[i]==s[st])
        {
            f[st][ed][p]=max(f[st][ed][p],why(st+1,i-1,1)+why(i,ed,p+1));
        }  
    return f[st][ed][p];    
}
int main()
{
    scanf("%d",&n);
    scanf("%s",s+1);
    for (int i=1;i<=n;i++) scanf("%lld",&a[i]);
    memset(f,-1,sizeof(f));
    printf("%lld",why(1,n,1));
 }

 

F. Vasya and Endless Credits

题意:有500张信用卡,你每个月只能选择得到最多一张,a,b,k表示办这张卡的时候你得到a元,以后每个月还b元,共k个月

        你可以在任意时刻跑路(凭本事借的为什么要还),问你最多能带多少钱跑路

题解:看起来很像费用流啊!,我们可以对每张信用卡build(S,i,1,0),再定义这是倒数第几个月build(j,T,1,0)

        信用卡对月份连接的意思就是,这张卡i在倒数第j个月的时候借了能获得的钱,(可能k大于j,还不完就跑)

        这样就能得到答案,但是复杂度有点不允许,因为边数太多.

       再发现这其实也是一个二分图且流量都一样为1,我们可以直接用二分图的最大权匹配(KM)来做,就少了一个n的代价

       好像其实这道题dp做法n*n的?快的飞起?

       (hsj板子218ms)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=500+5;
const int inf=0x3f3f3f3f;
const ll linf=1e18;

int n;

ll w[maxn][maxn],slack[maxn],x[maxn],y[maxn];
ll prev_x[maxn],prev_y[maxn],son_y[maxn],par[maxn];
ll lx,ly,pop;
void adjust(int v)
{
    son_y[v]=prev_y[v];
    if(prev_x[son_y[v]]!=-2)adjust(prev_x[son_y[v]]);
}

bool findd(int v)
{
    for(ll i=0;i<pop;i++)
        if(prev_y[i]==-1)
        {
            if(slack[i]>x[v]+y[i]-w[v][i])
            {
                slack[i]=x[v]+y[i]-w[v][i];
                par[i]=v;
            }
            if(x[v]+y[i]==w[v][i])
            {
                prev_y[i]=v;
                if(son_y[i]==-1)
                {
                    adjust(i);
                    return 1;
                }
                if(prev_x[son_y[i]]!=-1) continue;
                prev_x[son_y[i]]=i;
                if(findd(son_y[i])) return 1;
            }
        }
    return 0;
}

ll km()
{
    ll i,j,m;
    for(i=0;i<pop;i++)
    {
        son_y[i]=-1;
        y[i]=0;
    }
    for(i=0;i<pop;i++)
    {
        x[i]=0;
        for(j=0;j<pop;j++) x[i]=max(x[i],w[i][j]);
    }
    bool flag;
    for(i=0;i<pop;i++)
    {
        for(j=0;j<pop;j++)
        {
            prev_x[j]=prev_y[j]=-1;
            slack[j]=linf;
        }
        prev_x[i]=-2;
        if(findd(i))continue;
        flag=false;
        while(!flag)
        {
            m=inf;
            for(j=0;j<pop;j++)
                if(prev_y[j]==-1) m=min(m,slack[j]);
            for(j=0;j<pop;j++)
            {
                if(prev_x[j]!=-1) x[j]-=m;
                if(prev_y[j]!=-1) y[j]+=m;else slack[j]-=m;
            }
            for(j=0;j<pop;j++)
                if(prev_y[j]==-1&&!slack[j])
                {
                    prev_y[j]=par[j];
                    if(son_y[j]==-1)
                    {
                        adjust(j);
                        flag=true;
                        break;
                    }
                    prev_x[son_y[j]]=j;
                    if(findd(son_y[j]))
                    {
                        flag=true;
                        break;
                    }
                }
        }
    }
    ll ans=0;
    for (int i=0;i<pop;i++)ans+=w[son_y[i]][i];
    return ans;
}

ll a,b,k;
int main()
{
    //freopen("in.txt","r",stdin);
    scanf("%d",&n);
    pop=n;
    for (int i=0;i<n;i++)
    {
        scanf("%lld%lld%lld",&a,&b,&k);
        for(int j=0;j<n;j++)
        {
            ll vv=a-min(k,(ll)j)*b;
            w[i][j]=max(vv,0LL);
        }
    }
    printf("%lld\n",km());
    return 0;
}

 

        (kuangbin板子2136ms)

#include<bits/stdc++.h>
using namespace std;
#define N 505
#define lld long long 
const lld INF = 1e18;
int nx,ny;//两边的点数
lld g[N][N];//二分图描述
int linker[N];
lld lx[N],ly[N];//y中各点匹配状态，x,y中的点标号
lld slack[N];
bool visx[N],visy[N];
bool DFS(int x)
{
    visx[x] = true;
    for(int y = 0; y < ny; y++)
    {
        if(visy[y])continue;
        lld tmp = lx[x] + ly[y] - g[x][y];
        if(tmp == 0)
        {
            visy[y] = true;
            if(linker[y] == -1 || DFS(linker[y]))
            {
                linker[y] = x;
                return true;
            }
        }
        else if(slack[y] > tmp) slack[y] = tmp;
    }
    return false;
}
lld KM()
{
    memset(linker,-1,sizeof(linker));
    //memset(ly,0,sizeof(ly));
    for(int i = 0;i < nx;i++)
    {
        lx[i] = -INF;
        for(int j = 0;j < ny;j++)
            if(g[i][j] > lx[i]) lx[i] = g[i][j];
    }
    for(int x = 0;x < nx;x++)
    {
        for(int i = 0;i < ny;i++) slack[i] = INF;
        while(true)
        {
            for (int i=0;i<nx;i++) visx[i]=0;
            for (int i=0;i<ny;i++) visy[i]=0;
            if(DFS(x))break;
            lld d = INF;
            for(int i = 0;i < ny;i++)
                if(!visy[i] && d > slack[i]) d = slack[i];
            for(int i = 0;i < nx;i++)
                if(visx[i]) lx[i] -= d;
            for(int i = 0;i < ny;i++)
                  if(visy[i])ly[i] += d; else slack[i] -= d;
            
        }
    }
    lld res = 0;
    for(int i = 0;i < ny;i++)
        if(linker[i] != -1) res += g[linker[i]][i];
    return res;
}
lld a,b,k;
int main()
{
    //freopen("in.txt","r",stdin);
    int n;
    while(scanf("%d",&n) == 1)
    {
        for (int i=0;i<n;i++)
        {
            scanf("%lld%lld%lld",&a,&b,&k);
            for(int j=0;j<n;j++)
            {
                lld vv=a-min(k,(lld)j)*b;
                g[i][j]=max(vv,0LL);
            }
        }
        nx = ny = n;
        printf("%lld\n",KM());
    }
    return 0;
}

 

G. Vasya and Maximum Profit

题意:给一个n(3e5)个元素的数组ci,和一个n元素的严格上升的数组di和一个数a,求最大的a*(r-l+1)-sigma(i=l to r)c[i]-gap(l,r);

       gap(l,r)=max( (d[i+1]-d[i])^2 )(i= l to r)

题解:首先可把a放进每一项里,a*(r-l+1)-sigma(i=l to r)c[i] 变成 sigma(i=l to r)a-c[i],这个用线段树就可以维护最大连续和

        对于gap,我们可以统计每个d[i+1]-d[i]能管的到的最长区间是多少,用单调栈O(n)预处理

        再枚举这些最大区间求区间里最大连续和就好.

#include <bits/stdc++.h>
using namespace std;
#define LL long long 
const int N = 3e5 + 10;
struct tree 
{
    LL sum, rmx, lmx, mx;
}sgt[N << 2];
int c[N], d[N], diff[N], a, n, l[N], r[N];
long long ans;
void pushup(int rt) 
{
    sgt[rt].sum = sgt[rt << 1].sum + sgt[rt << 1 | 1].sum;
    sgt[rt].mx = max(sgt[rt << 1].mx, sgt[rt << 1 | 1].mx);
    sgt[rt].lmx = max(sgt[rt << 1].lmx, sgt[rt << 1].sum + sgt[rt << 1 | 1].lmx);
    sgt[rt].rmx = max(sgt[rt << 1 | 1].rmx, sgt[rt << 1 | 1].sum + sgt[rt << 1].rmx);
    sgt[rt].mx = max(sgt[rt].mx, sgt[rt << 1].rmx + sgt[rt << 1 | 1].lmx);
}

void build(int rt, int l, int r) 
{
    if(l == r) 
    {
        sgt[rt].sum = sgt[rt].lmx = sgt[rt].rmx = sgt[rt].mx = c[l];
        return;
    }
    int mid = l + r >> 1;
    build(rt << 1, l, mid);
    build(rt << 1 | 1, mid + 1, r);
    pushup(rt);
}
tree query(int rt, int l, int r, int L, int R) 
{
    if(L <= l && r <= R) return sgt[rt];
    int mid = l + r >> 1;
    if(R <= mid) return query(rt << 1, l, mid, L, R);
    if(L > mid)  return query(rt << 1 | 1, mid + 1, r, L, R);
    tree u = query(rt << 1, l, mid, L, R), v = query(rt << 1 | 1, mid + 1, r, L, R), o;
    o.sum = u.sum + v.sum;
    o.mx = max(u.mx, v.mx);
    o.mx = max(o.mx, u.rmx + v.lmx);
    o.lmx = max(u.lmx, u.sum + v.lmx);
    o.rmx = max(v.rmx, v.sum + u.rmx);
    return o;
}
struct node 
{
    int val, id;
};
int main() 
{
    scanf("%d%d",&n,&a);
    for (int i=1;i<=n;i++)
    {
        scanf("%d%d",&d[i],&c[i]);
        c[i]=a-c[i];
        ans=max(ans,(LL)c[i]);
    }
    for (int i=1;i<n;i++) diff[i]=d[i+1]-d[i];
    build(1,1,n);
    stack<node> stk;
    stk.push({(int)1e9, 0});
    for (int i=1;i<n;i++)
    {        
        while (stk.top().val<=diff[i]) stk.pop();
        l[i]=stk.top().id+1;
        stk.push({diff[i],i});
    }
    while (!stk.empty()) stk.pop();
    stk.push({(int)1e9,n});
    for (int i = n - 1; i; --i) 
    {
        while(stk.top().val <= diff[i]) stk.pop();
        r[i] = stk.top().id;
        stk.push({diff[i], i});
    }
    for(int i=1;i<n;i++)
        ans=max(ans, query(1,1,n,l[i],r[i]).mx - (LL)diff[i] * diff[i]);
    printf("%lld\n",ans);
    return 0;
}