Codeforces Round #724 (Div. 2)

最新推荐文章于 2021-10-09 11:43:00 发布

我的故事用酒换

最新推荐文章于 2021-10-09 11:43:00 发布

阅读量230

点赞数

分类专栏： codeforces日记文章标签：算法

本文链接：https://blog.csdn.net/weixin_46113968/article/details/117677035

版权

codeforces日记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

2021.6.6

题解：如果出现负数直接输出NO，负数只会让数越开越大，都为正数直接输出0到出现的最大值，最

多也就输出101个，差值就都是1。

#include <iostream>
#include <algorithm>
using namespace std;
const int N=305;
ll a[N];
int main()
{
    ios_base::sync_with_stdio(false);
    int n,t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        ll flag=0,maxx=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            if(a[i]<0)
                flag=1;
            maxx=max(maxx,a[i]);
        }
        if(flag)
            cout<<"NO"<<endl;
        else
        {
            cout<<"YES"<<endl;
            cout<<maxx+1<<endl;
            for(int i=0;i<=maxx;i++)
                cout<<i<<' ';
            cout<<'\n';
        }
    }

    return 0;
}

题解：直接从字典序最小的开始找判断是否为子字符串，是就直接输出，不是找下一个，因为长度最多为1000，那么如果子字符串长度为3，那么子字符串种类最多为1000-2=998种，而长度为3的字符串种类有26*26*26种，显然必有一种长度为3的字符串不是子字符串，所以只需要找到长度为3的就可以了。

#include <iostream>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
const int N=1005;
int n;
string s;
int solve(string s1)
{
    //cout<<s1<<endl;
    int flag=1;
    int len=s1.size();
    for(int i=0;i<n-len+1;i++)
    {
        int j;
        for(j=0;j<len;j++)
        {
            if(s1[j]!=s[j+i])
            {
                break;
            }
        }
        if(j==len)
        {
            flag=0;
            break;
        }
    }
    return flag;
}
int main()
{
    ios_base::sync_with_stdio(false);
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>s;
        int flag=0;
        string s1;
        for(int i=0;i<=26;i++)
        {
            for(int j=0;j<=26;j++)
            {
                for(int k=0;k<26;k++)
                {
                    s1="";
                    if(i)
                        s1+=('a'+i-1);
                    if(j)
                        s1+=('a'+j-1);
                    s1+=('a'+k);
                    if(solve(s1))
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag)
                    break;
            }
            if(flag)
                break;
        }
        cout<<s1<<endl;
    }

    return 0;
}

题意：可以分成比例相等的最大块数。

题解：每次输出比例相等出现的次数，因为比如DDK是2:1，那DDKKDD也满足2:1，那么因为前面出现过2:1，那么后面的KDD一定也是2:1，所以出现的次数就肯定就是可以分割的块数。

#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
int main()
{
    string s;
    int t,n;
    cin>>t;
    while(t--)
    {
        map<pair<int,int>,int>m;
        cin>>n>>s;
        int d=0,k=0;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='D')
                d++;
            else
                k++;
            int g=gcd(k,d);
            int k1=k/g;
            int d1=d/g;
            m[make_pair(d1,k1)]++;
            cout<<m[make_pair(d1,k1)]<<' ';
        }
        cout<<'\n';
    }
    return 0;
}

题意：输入长度为n的序列b，要求找出是否存在序列a，使得序列b都满足其中 $a_{1}-a_{i*2-1}$ 包含 $b_{1}-b_{i}$ 且 $b_{i}$ 为序列 $a_{1}-a_{i*2-1}$ 的中位数。

题解：先将 $b_{1}$ 放到序列a里，这样必为中位数，然后根据前面 $b_{i}$ 为中位数满足的序列 $a_{2*i-1}$ 插入 $a_{2*i} and a_{2*i+1}$ ，其中一个就是 $b_{i+1}$ ，如果 $b_{i}$ > $b_{i+1}$ 那么 $b_{i+1}$ 就必须插到 $b_{i}$ 的前一个， $a_{2*i} and a_{2*i+1}$ 多出来的那个刚好抵消掉 $b_{i}$ ，这样 $b_{i+1}$ 就又是中位数，当 $b_{i}$ < $b_{i+1}$ 那么 $b_{i+1}$ 就必须插到 $b_{i}$ 的后一个，如果 $b_{i}$ = $b_{i+1}$ ，那易知一定可以满足。

#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
const int N=200005;
int a[N];
int main()
{
    std::ios::sync_with_stdio(false), std::cin.tie(0);
    int t,n;
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
            cin>>a[i];
        int flag=1;
        set<int>s;
        set<int>::iterator it;
        s.insert(a[1]);
        for(int i=2;i<=n;i++)
        {
            int pre=a[i-1];
            if(pre<a[i])
            {
                it=s.upper_bound(pre);
                if(it!=s.end()&&(*it<a[i]))
                {
                    flag=0;
                    break;
                }
            }
            else if(pre>a[i])
            {
                it=s.lower_bound(pre);
                if(it!=s.begin()&&(*(--it)>a[i]))
                {
                    flag=0;
                    break;
                }
            }
            s.insert(a[i]);
        }
        if(flag)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

题意：输入n*m的网格，其中只包含'0'或'#'，为字符'0'代表这个单元格必须为0，为'#'代表这个单元格可以填任意非负整数，求满足网格条件的所以情况。要求这个网格需要满足：

1.任意相邻单元格数字差绝对值至多为1

2.如果单元格数字大于0，则至少有一个相邻单元格数字小于该单元格数字

题解：对于每一个单元格为'#'其实只有两种方案填数字，可以为0，若不为0则该单元格数字就根据相邻单元格确定为一个固定数字，所以答案为字符'#'的个数ans的2次方。需要考虑都为’#‘的情况就答案-1，因为肯定有一个单元格必须为0，（假设所以单元格都为正整数，那必存在最小的那个数相邻的单元格数字都大于等于它，不满足第二点）。

#include <iostream>
#include <algorithm>
#define mod 1000000007
#define ll long long
using namespace std;
const int N=2005;
char s[N][N];
int main()
{
    std::ios::sync_with_stdio(false), std::cin.tie(0);
    int t,n,m;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++)
        {
            cin>>(s[i]+1);
        }
        int flag=0;
        ll ans=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(s[i][j]=='0')
                {
                    flag=1;
                }
                else
                {
                    ans=ans*2%mod;
                }
            }
        }
        if(flag)
            cout<<ans<<endl;
        else
            cout<<ans-1<<endl;
    }
    return 0;
}