Codeforces Round #147 (Div. 2)-优快云博客

本文探讨了在编程比赛中如何解决不同类型的难题，包括排序算法的应用、字符串匹配和优化策略。通过实例分析，展示了如何高效地解决比赛中的问题，提供了具体的代码实现和优化思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这场比赛做出了2道题，第三道因为没有输入文件结束，导致一直超时。。。。。。。非常非常伤感

a题，我方法比较的笨，输入好再排序

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <queue>
using namespace std;
#define N 300000
#define Dbag printf("haha\n");
struct node
{
    int h,m;
}a[N];
int cmp(node a, node b)
{
    if(a.h!=b.h)
        return a.h<b.h;
    else
        return a.m<b.m;
}
int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 0; i < n; i++)
            scanf("%d%d", &a[i].h, &a[i].m);
        sort(a, a+n, cmp);
        int ans = 0;
        for(int i = 0; i < n-1; i++)
        {
            int cnt = 0;
            if(a[i].h==a[i+1].h&&a[i].m==a[i+1].m)
            {
                cnt++;
                int j = i+1;
                while(j<n-1)
                {
                    if(a[j].h==a[j+1].h&&a[j].m==a[j+1].m)
                    {
                        j++;cnt++;
                    }
                    else
                        break;
                }
                i = j;
                ans = max(ans,cnt);
            }
        }
        printf("%d\n",ans+1);
    }
    return 0;
}

B题

不要被他的样例输出误导，题目说了，不要求最小交换次数，我只要按着1,2,3,4,5。。。。n直接换，最多s-1次

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <queue>
using namespace std;
#define N 300
#define Dbag printf("haha\n");
int data[N][N], order[N][N];
int ans[N][4];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int c[N];
        for(int i = 1; i <= n; i++)
            scanf("%d", &c[i]);
        int cnt = 0, oprea = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= c[i]; j++)
            {
                scanf("%d",&data[i][j]);
                order[i][j] = ++cnt;
            }
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= c[i]; j++)
            {
                if(data[i][j]!=order[i][j])
                {
                    int flag = 0;
                    for(int k = i; k <= n; k++)
                    {
                        for(int l = 1; l <= c[k]; l++)
                        {
                            if(data[k][l]==order[i][j])
                            {
                                ans[oprea][0]=i;ans[oprea][1]=j;
                                ans[oprea][2]=k;ans[oprea++][3]=l;
                                int temp = data[k][l];
                                data[k][l]=data[i][j];
                                data[i][j]=temp; flag =1;
                                break;
                            }
                        }
                        if(flag)
                            break;
                    }
                }
            }
        printf("%d\n", oprea);
        for(int i = 0; i < oprea; i++)
            printf("%d %d %d %d\n", ans[i][0],ans[i][1],ans[i][2],ans[i][3]);
    }
    return 0;
}

C题的话我先线性筛1e6的素数，然后建立树状数组；

枚举l的时候从k开始，并且如果a---b之间的素数比k小的话，直接输出-1；

l的话，二分查找,行了，我的优化就这么多了，后边交了下300多ms，还行，不多说，直接上代码

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <string>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;
#define N 1000001
bool isp[N];
int lp;
long long prime[N];

void gao()
{
    memset(isp,true,sizeof(isp));
    isp[0]=isp[1]=false;
    lp=0;
    for(long long  i = 2; i < N; i++)
    {
        if(isp[i])
            prime[lp++]=i;
        for(long long j = 0; j<lp&&prime[j]*i<N;j++)
        {
            isp[prime[j]*i]=false;
            if(i%prime[j]==0)
                break;
        }
    }
}

int c[N];
int lowbit(int x) //求某节点的2^k
{
    return (-x)&x;
}
//在树状数组中，将id处的元素+v，n为数组边界
void update(int id, int v, int n)
{
    int cur = id;
    while(cur<=n)
    {
        c[cur] += v;
        cur += lowbit(cur);//为cur节点的父节点
    }
}
//求出a[1]到a[id]的和
int querysum(int id)
{
    int ret = 0;
    int cur = id;
    while(cur > 0)
    {
        ret += c[cur];
        cur -= lowbit(cur); //即求cur节点的前一颗子树
    }
    return ret;
}

void build()
{
    memset(c,0,sizeof(c));
    for(int i = 0; i < N; i++)
        if(isp[i])
            update(i, 1, N);
}
int main()
{
    gao();
    build();
    int a, b, k;
    while(~scanf("%d%d%d", &a, &b, &k))
    {
        int l, flag;
        if(querysum(b)-querysum(a-1)<k)
        {
            printf("-1\n");
            continue;
        }
        int left = k, right = b-a+1;
        while(left<right)
        {
            int l = (left+right)>>1;
            flag = 1;
            int x;
            for(x = a; x <= b-l+1; x++)
            {
                if(querysum(x+l-1)-querysum(x-1)<k)
                {
                    flag = 0;
                    break;
                }
                else
                {
                    while(!isp[x])
                        x++;
                }
            }
            if(flag)
                right = l;
            else
                left = l+1;
        }
        flag = 1;
        int x;
        for(x = a; x <= b-right+1; x++)
        {
            if(querysum(x+right-1)-querysum(x-1)<k)
            {
                flag = 0;
                break;
            }
            else
            {
                while(!isp[x])
                    x++;
            }
            if(flag)
                break;
        }
        if(flag)
            printf("%d\n", right);
        else
            printf("-1\n");
    }
}