Educational Codeforces Round 72 (Rated for Div. 2)

链接
A. Creating a Character(签到)
略
B.Zmei Gorynich(签到)
略
C.The Number Of Good Substrings
题意: 给你一个01串，问存在多少个子串的长度等于子串转换成十进制的数
思路: 因为长度最大只有2e5，也就是说顶多子串含有1的长度不超过18，也就是说2^18>2e5,所以可以从这里优化，因为预处理每个位置前面1的位置，若该子串目前小于转换成二进制的，可以补0，所以可以看与前面的1相差多少位，0是否充足补

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
char s[N];
int  pre[N];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",s+1);
        int len=strlen(s+1);
 
        for(int i=1;i<=len;i++)
        {
            if(s[i]=='1')
                pre[i]=i;
            else
                pre[i]=pre[i-1];
        }
        int ans=0;
        for(int i=1;i<=len;i++)
        {
            int sum=0;
            for(int j=i;i-j<=18&&j>0;j--)
            {
                if(s[j]=='0')
                    continue;
                sum+=1<<(i-j);
                if(sum<=i-pre[j-1])
                    ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

D.Coloring Edges
题意: 给你一个有向图，给边染色，一个环不能只含一种颜色，问最小的颜色数，且输出边的一个染色方案
思路: 我们可以知道只要存在环的，就两种颜色，不然就一种
且有个结论：对于有向图的环，一定同时存在编号小的点指向编号大的点和编号大的点指向编号小的点的边
因此，我们把所有小指大的边染为1，大指小的边染为2，就能保证图中不存在同色环。那么问题就演变成了判断图中是否有环，这个就随便搞搞，拓扑排序啊dfs啊都可以。

#include<bits/stdc++.h>
using namespace std;
const int N=5005;
int l[N],r[N];
int n,m,flag;
int vis[N];
vector<int>edge[N];
void dfs(int u)
{
    if(flag)
        return ;
    vis[u]=1;
    for(int i=0;i<edge[u].size();i++)
    {
        int v=edge[u][i];
        if(vis[v]==1)
        {
            flag=1;
            return ;
        }
        else if(vis[v]==0)
            dfs(v);
 
    }
    vis[u]=2;
}
 
int main()
{
 
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        l[i]=u,r[i]=v;
        edge[u].push_back(v);
    }
    for(int i=1;i<=n;i++)
        if(!flag&&!vis[i])
            dfs(i);
    if(flag)
    {
        puts("2");
        for(int i=1;i<=m;i++)
        {
            if(l[i]<r[i])
                printf("1 ");
            else
                printf("2 ");
        }
    }
    else
    {
        puts("1");
        for(int i=1;i<=m;i++)
            printf("1 ");
    }
    puts("");
    return 0;
}

E.Sum Queries?
题意: 给你一个长度为n的数组，有m次操作：
1，单点修改某个位置的数
2，问在[l,r]中是否存在所定义的不平衡数集合，如果有输出最小的集合总和
不平衡集合定义：里面所有的数至少有两个数的在某位数上均不为0
思路: 因为数<=1e9,所以我们可以建立10颗线段树，分别存储每一位上最小的两个数
注意：细节很多，稍微写错，需要找很久的BUG，例如当某位上为0时，不能update到线段树，修改时，先将某个数覆盖掉，再update新的数

#include<bits/stdc++.h>
#define lson root<<1,l,mid
#define rson root<<1|1,mid+1,r
#define INF 0x3f3f3f3f
using namespace std;
const int N=2e5+5;
int n,m;
int ans1,ans2,ans;
struct node
{
    int min1[N<<2],min2[N<<2];
    void init()
    {
        memset(min1,0x3f,sizeof min1);
        memset(min2,0x3f,sizeof min2);
    }
    void update(int root,int l,int r,int pos,int x)
    {
        if(l==r)
        {
            min1[root]=x;
            min2[root]=INF;
            return ;
        }
        int mid=(l+r)>>1;
        if(pos<=mid)
            update(lson,pos,x);
        else
            update(rson,pos,x);
        min2[root]=min(max(min1[root<<1],min1[root<<1|1]),min(min2[root<<1],min2[root<<1|1]));
        min1[root]=min(min1[root<<1],min1[root<<1|1]);
    }
    void query(int root,int l,int r,int L,int R)
    {
        if(L<=l&&r<=R)
        {
            ans2=min(min(min2[root], ans2), max(min1[root], ans1));
            ans1=min(min1[root], ans1);
            return;
        }
        int mid=(l+r)>>1;
        if(L<=mid)
            query(lson,L,R);
        if(R>mid)
            query(rson,L,R);
        return;
    }
 
}tree[12];
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=10;i++)
        tree[i].init();
    for(int i=1;i<=n;i++)
    {
        int tmp,x,cnt=0;
        scanf("%d",&x);
        tmp=x;
        while(tmp)
        {
            cnt++;
            if(tmp%10)
                tree[cnt].update(1,1,n,i,x);
            tmp/=10;
        }
    }
    for(int i=1;i<=m;i++)
    {
        int op,l,r;
        scanf("%d%d%d",&op,&l,&r);
        if(op==1)
        {
            int tmp=r;
            for(int j=1;j<=10;j++)
            {
                tree[j].update(1,1,n,l,INF);
            }
            int cnt=0;
            while(tmp)
            {
                cnt++;
                if(tmp%10)
                    tree[cnt].update(1,1,n,l,r);
                tmp/=10;
            }
        }
        else
        {
            ans=INF*2;
            for(int j=1;j<=10;j++)
            {
                ans1=ans2=INF;
                tree[j].query(1,1,n,l,r);
                if(ans1!=INF&&ans2!=INF&&ans>ans1+ans2)
                    ans=ans1+ans2;
            }
            if(ans!=INF*2)
                printf("%d\n",ans);
            else
                puts("-1");
        }
    }
    return 0;
}